@promptdriven/pds 0.1.0

package/dist/commands/registry.js

@@ -0,0 +1,987 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchCommand = dispatchCommand;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const config_1 = require("../config/config");
+const errors_1 = require("../errors/errors");
+const DEFAULT_LOGIN_SCOPES = [
+    "project:create",
+    "project:read",
+    "project:write",
+    "pipeline:run",
+    "artifact:read",
+    "distribution:package",
+    "distribution:publish",
+    "token:manage"
+];
+const RELEASE_VIDEO_REATTACH_MAX_ATTEMPTS = 8;
+const RELEASE_VIDEO_REATTACH_INITIAL_DELAY_MS = 250;
+const RELEASE_VIDEO_REATTACH_MAX_DELAY_MS = 5_000;
+const RELEASE_VIDEO_WAIT_MAX_CONFIRMATIONS = 60;
+const RELEASE_VIDEO_WAIT_POLL_MS = 1_000;
+const PRIVATE_INTERNAL_ERROR_DETAIL_KEY_PATTERN = /^(?:errorName|rootCause|raw(?:Provider)?(?:Payload|Response|Error|Message)?|providerRaw(?:Payload|Response|Error|Message)?)$/i;
+async function dispatchCommand(commandPath, commandArgs, context) {
+    const command = commandPath.join(" ");
+    switch (command) {
+        case "auth login":
+            return await authLogin(commandArgs, context);
+        case "auth status":
+            ensureNoCommandArgs(commandArgs);
+            return await context.client.getAuthStatus();
+        case "auth logout":
+            ensureNoCommandArgs(commandArgs);
+            return await (0, config_1.logoutProfile)({ configRoot: context.configRoot, env: context.env, profile: context.config.profile });
+        case "auth token create":
+            return await authTokenCreate(commandArgs, context);
+        case "auth token list":
+            ensureNoCommandArgs(commandArgs);
+            return await context.client.listTokens();
+        case "auth token revoke":
+            return await authTokenRevoke(commandArgs, context);
+        case "projects create":
+            return await projectsCreate(commandArgs, context);
+        case "project get":
+            ensureNoCommandArgs(commandArgs);
+            return await context.client.getProject(requireProject(context.config));
+        case "project reset-pipeline":
+            return await projectResetPipeline(commandArgs, context);
+        case "script get":
+            return await context.client.getScript({ projectId: requireProject(context.config), file: optionalString(parse(commandArgs, { file: "string" }).file) });
+        case "script set":
+            return await scriptSet(commandArgs, context);
+        case "artifacts list":
+            ensureNoCommandArgs(commandArgs);
+            return await context.client.listArtifacts(requireProject(context.config));
+        case "pipeline plan":
+            return await context.client.planPipeline({
+                projectId: requireProject(context.config),
+                to: optionalString(parse(commandArgs, { to: "string" }).to)
+            });
+        case "pipeline status":
+            ensureNoCommandArgs(commandArgs);
+            return await context.client.getPipelineStatus({
+                projectId: requireProject(context.config)
+            });
+        case "pipeline run": {
+            const values = parse(commandArgs, {
+                to: "string",
+                stage: "string",
+                mode: "string",
+                "dry-run": "boolean",
+                "force-regenerate": "boolean",
+                wait: "boolean",
+                "idempotency-key": "string"
+            });
+            const dryRun = values["dry-run"] === true;
+            const response = await context.client.runPipeline(compact({
+                projectId: requireProject(context.config),
+                to: optionalString(values.to),
+                stage: optionalString(values.stage),
+                mode: optionalString(values.mode),
+                dryRun: dryRun || undefined,
+                forceRegenerate: values["force-regenerate"] === true || undefined,
+                wait: values.wait === true || undefined,
+                idempotencyKey: mutationIdempotencyKey(values["idempotency-key"], dryRun)
+            }));
+            await followAgentRunEvents(response, context);
+            return response;
+        }
+        case "jobs watch": {
+            const values = parse(commandArgs, { "job-id": "string", "run-id": "string" });
+            return await context.client.watchJob({
+                jobId: requiredRunOrJobId(values),
+                onEvent: context.emitJsonlEvent
+            });
+        }
+        case "jobs cancel": {
+            const values = parse(commandArgs, { "job-id": "string" });
+            return await context.client.cancelJob({ jobId: requiredString(values["job-id"], "--job-id") });
+        }
+        case "distribution generate": {
+            const values = parse(commandArgs, { platform: "string", mode: "string", "dry-run": "boolean", "force-regenerate": "boolean", "idempotency-key": "string" });
+            const dryRun = values["dry-run"] === true;
+            return await context.client.generateDistribution(compact({
+                projectId: requireProject(context.config),
+                platform: optionalString(values.platform),
+                mode: optionalString(values.mode),
+                dryRun: dryRun || undefined,
+                forceRegenerate: values["force-regenerate"] === true || undefined,
+                idempotencyKey: mutationIdempotencyKey(values["idempotency-key"], dryRun)
+            }));
+        }
+        case "distribution status": {
+            const values = parse(commandArgs, { platform: "string" });
+            return await context.client.getDistributionStatus(compact({
+                projectId: requireProject(context.config),
+                platform: optionalString(values.platform)
+            }));
+        }
+        case "distribution connections list": {
+            const values = parse(commandArgs, { platform: "string" });
+            return await context.client.listDistributionConnections(compact({
+                projectId: requireProject(context.config),
+                platform: optionalString(values.platform)
+            }));
+        }
+        case "distribution connection select": {
+            const values = parse(commandArgs, { platform: "string", "connection-id": "string" });
+            return await context.client.selectDistributionConnection(compact({
+                projectId: requireProject(context.config),
+                platform: optionalString(values.platform),
+                connectionId: requiredString(values["connection-id"], "--connection-id")
+            }));
+        }
+        case "distribution publish": {
+            const values = parse(commandArgs, {
+                platform: "string",
+                privacy: "string",
+                "dry-run": "boolean",
+                "force-regenerate": "boolean",
+                "no-generate": "boolean",
+                "override-audit": "boolean",
+                "audit-override-rationale": "string",
+                wait: "boolean",
+                "idempotency-key": "string"
+            });
+            const dryRun = values["dry-run"] === true;
+            const response = await context.client.publishDistribution(compact({
+                projectId: requireProject(context.config),
+                platform: optionalString(values.platform),
+                privacy: optionalString(values.privacy),
+                dryRun: dryRun || undefined,
+                forceRegenerate: values["force-regenerate"] === true || undefined,
+                noGenerate: values["no-generate"] === true || undefined,
+                overrideAudit: values["override-audit"] === true || undefined,
+                auditOverrideRationale: optionalString(values["audit-override-rationale"]),
+                wait: values.wait === true || undefined,
+                idempotencyKey: mutationIdempotencyKey(values["idempotency-key"], dryRun)
+            }));
+            await followAgentRunEvents(response, context);
+            return response;
+        }
+        case "release-video create":
+            return await releaseVideoCreate(commandArgs, context);
+        case "release-video status":
+            return await releaseVideoStatus(commandArgs, context);
+        default:
+            throw new errors_1.CliError(commandPath.length ? `Unknown command: ${commandPath.join(" ")}` : "Missing command", {
+                code: "unknown_command",
+                exitCode: errors_1.EXIT_CODES.usage
+            });
+    }
+}
+async function authLogin(commandArgs, context) {
+    const values = parse(commandArgs, {
+        scopes: "string",
+        "expires-in": "string",
+        "expires-at": "string"
+    });
+    const scopes = optionalString(values.scopes)
+        ?.split(",")
+        .map((scope) => scope.trim())
+        .filter(Boolean) ?? DEFAULT_LOGIN_SCOPES;
+    const projectIds = context.config.projectId
+        ? [context.config.projectId]
+        : defaultLoginProjectIds(context.config.apiUrl);
+    const expiresAt = resolveExpiryIso(optionalString(values["expires-at"]), optionalString(values["expires-in"]) ?? "30d");
+    const startResponse = await context.client.startDeviceLogin({
+        scopes,
+        projectIds,
+        expiresAt
+    });
+    const startData = readEnvelopeData(startResponse);
+    const deviceCode = requiredString(startData.deviceCode, "deviceCode");
+    const verificationUri = optionalString(startData.verificationUri);
+    const userCode = optionalString(startData.userCode);
+    if (verificationUri) {
+        context.emitJsonlEvent?.({
+            type: "device_login_started",
+            verificationUri,
+            userCode,
+            expiresAt: optionalString(startData.expiresAt)
+        });
+        context.notice?.(`Open this URL to approve CLI login: ${verificationUri}`);
+        if (userCode) {
+            context.notice?.(`Device code: ${userCode}`);
+        }
+        if (context.openUrl) {
+            await context.openUrl(verificationUri);
+        }
+    }
+    const completeResponse = await pollDeviceLoginCompletion(context, deviceCode, startData);
+    const completeData = readEnvelopeData(completeResponse);
+    const rawToken = requiredString(completeData.rawToken, "rawToken");
+    const token = isRecord(completeData.token) ? completeData.token : {};
+    const tokenId = optionalString(token.id);
+    await (0, config_1.loginProfile)({
+        configRoot: context.configRoot,
+        env: context.env,
+        profile: context.config.profile,
+        token: rawToken
+    });
+    await (0, config_1.saveProfileConfig)({
+        configRoot: context.configRoot,
+        env: context.env,
+        profile: context.config.profile,
+        apiUrl: context.config.apiUrl,
+        projectId: context.config.projectId
+    });
+    return {
+        ok: true,
+        profile: context.config.profile,
+        apiUrl: context.config.apiUrl,
+        tokenId,
+        device: {
+            userCode: optionalString(readEnvelopeData(startResponse).userCode),
+            verificationUri: optionalString(readEnvelopeData(startResponse).verificationUri)
+        }
+    };
+}
+function defaultLoginProjectIds(apiUrl) {
+    if (isLocalApiUrl(apiUrl)) {
+        return "*";
+    }
+    throw new errors_1.CliError("Missing project id. Pass --project or set PDS_PROJECT_ID.", {
+        code: "missing_project",
+        exitCode: errors_1.EXIT_CODES.usage
+    });
+}
+function isLocalApiUrl(apiUrl) {
+    try {
+        const hostname = new URL(apiUrl).hostname.toLowerCase();
+        return hostname === "localhost" ||
+            hostname === "127.0.0.1" ||
+            hostname === "0.0.0.0" ||
+            hostname === "::1" ||
+            hostname === "[::1]";
+    }
+    catch {
+        return false;
+    }
+}
+async function pollDeviceLoginCompletion(context, deviceCode, startData) {
+    const sleep = context.sleep ?? defaultSleep;
+    const expiresAtMs = readExpiryMs(startData.expiresAt);
+    let intervalMs = readIntervalMs(startData.intervalSeconds, 1000);
+    let pendingPolls = 0;
+    while (true) {
+        try {
+            return await context.client.completeDeviceLogin({ deviceCode });
+        }
+        catch (error) {
+            if (!isPendingDeviceAuthorization(error)) {
+                throw error;
+            }
+            pendingPolls += 1;
+            intervalMs = readIntervalMs(readPendingIntervalSeconds(error), intervalMs);
+            context.emitJsonlEvent?.({
+                type: "device_login_pending",
+                poll: pendingPolls,
+                intervalSeconds: intervalMs / 1000
+            });
+            const now = Date.now();
+            if (now >= expiresAtMs) {
+                throw new errors_1.CliError("Device login session expired before approval", {
+                    code: "auth_required",
+                    exitCode: errors_1.EXIT_CODES.auth
+                });
+            }
+            await sleep(Math.min(intervalMs, Math.max(0, expiresAtMs - now)));
+        }
+    }
+}
+async function authTokenCreate(commandArgs, context) {
+    const values = parse(commandArgs, {
+        label: "string",
+        project: "string",
+        scopes: "string",
+        "expires-in": "string",
+        "expires-at": "string"
+    });
+    const projectId = optionalString(values.project) ?? requireProject(context.config);
+    const scopes = requiredString(values.scopes, "--scopes")
+        .split(",")
+        .map((scope) => scope.trim())
+        .filter(Boolean);
+    if (scopes.length === 0) {
+        throw new errors_1.CliError("Missing required option --scopes", { code: "missing_required_option", exitCode: errors_1.EXIT_CODES.usage });
+    }
+    return await context.client.createToken({
+        label: optionalString(values.label) ?? "pds cli token",
+        scopes,
+        projectIds: projectId === "*" ? "*" : [projectId],
+        expiresAt: resolveExpiryIso(optionalString(values["expires-at"]), optionalString(values["expires-in"]) ?? "30d")
+    });
+}
+async function authTokenRevoke(commandArgs, context) {
+    const values = parse(commandArgs, { "token-id": "string" });
+    return await context.client.revokeToken({
+        tokenId: requiredString(values["token-id"], "--token-id")
+    });
+}
+async function scriptSet(commandArgs, context) {
+    const values = parse(commandArgs, { file: "string", target: "string", "idempotency-key": "string" });
+    const idempotencyKey = requiredString(values["idempotency-key"], "--idempotency-key");
+    const sourcePath = requiredString(values.file, "--file");
+    const targetFile = normalizeScriptTarget(optionalString(values.target) ?? "main");
+    const content = await (0, promises_1.readFile)(sourcePath, "utf8");
+    return await context.client.setScript({
+        projectId: requireProject(context.config),
+        file: targetFile,
+        content,
+        idempotencyKey
+    });
+}
+async function projectsCreate(commandArgs, context) {
+    const values = parse(commandArgs, {
+        name: "string",
+        template: "string",
+        "project-id": "string",
+        "idempotency-key": "string"
+    });
+    const name = requiredString(values.name, "--name");
+    const projectId = optionalString(values["project-id"]) ??
+        (context.config.projectIdSource === "flag" ||
+            context.config.projectIdSource === "env"
+            ? context.config.projectId
+            : undefined);
+    return await context.client.createProject(compact({
+        name,
+        projectId,
+        template: optionalString(values.template),
+        idempotencyKey: requiredString(values["idempotency-key"], "--idempotency-key")
+    }));
+}
+async function projectResetPipeline(commandArgs, context) {
+    const values = parse(commandArgs, {
+        all: "boolean",
+        from: "string",
+        stage: "string",
+        "idempotency-key": "string",
+    });
+    const all = values.all === true;
+    const from = optionalString(values.from);
+    const stage = optionalString(values.stage);
+    const selectors = [
+        ...(all ? ["--all"] : []),
+        ...(from ? ["--from"] : []),
+        ...(stage ? ["--stage"] : []),
+    ];
+    if (selectors.length !== 1) {
+        throw new errors_1.CliError("Pass exactly one of --all, --from, or --stage", {
+            code: "invalid_arguments",
+            exitCode: errors_1.EXIT_CODES.usage,
+        });
+    }
+    return await context.client.resetPipeline(compact({
+        projectId: requireProject(context.config),
+        all: all ? true : undefined,
+        from,
+        stage,
+        idempotencyKey: requiredString(values["idempotency-key"], "--idempotency-key"),
+    }));
+}
+async function releaseVideoCreate(commandArgs, context) {
+    const values = parse(commandArgs, {
+        "project-name": "string",
+        script: "string",
+        "release-notes": "string",
+        changelog: "string",
+        "repo-url": "string",
+        "repo-name": "string",
+        "git-sha": "string",
+        "release-tag": "string",
+        preset: "string",
+        target: "string",
+        platform: "string",
+        privacy: "string",
+        "override-audit": "boolean",
+        "audit-override-rationale": "string",
+        "dry-run": "boolean",
+        "idempotency-key": "string",
+        wait: "boolean"
+    });
+    const dryRun = values["dry-run"] === true;
+    const idempotencyKey = mutationIdempotencyKey(values["idempotency-key"], dryRun);
+    const script = await fileContentRequest(optionalString(values.script));
+    const releaseNotes = await fileContentRequest(optionalString(values["release-notes"]));
+    const changelog = await fileContentRequest(optionalString(values.changelog));
+    const wait = !dryRun;
+    const requestPayload = compact({
+        projectName: optionalString(values["project-name"]),
+        projectId: context.config.projectIdSource === "flag" || context.config.projectIdSource === "env" ? context.config.projectId : undefined,
+        script,
+        releaseNotes,
+        changelog,
+        repoUrl: optionalString(values["repo-url"]),
+        repoName: optionalString(values["repo-name"]),
+        gitSha: optionalString(values["git-sha"]),
+        releaseTag: optionalString(values["release-tag"]),
+        preset: optionalString(values.preset),
+        target: optionalString(values.target),
+        platform: optionalString(values.platform),
+        privacy: optionalString(values.privacy),
+        overrideAudit: values["override-audit"] === true || undefined,
+        auditOverrideRationale: optionalString(values["audit-override-rationale"]),
+        dryRun: dryRun || undefined,
+        idempotencyKey,
+        wait: wait || undefined
+    });
+    const response = wait && !dryRun
+        ? await createReleaseVideoWithReattach(requestPayload, context)
+        : await context.client.createReleaseVideo(requestPayload);
+    if (wait && !dryRun) {
+        return await waitForReleaseVideoRun(response, context);
+    }
+    await followAgentRunEvents(response, context);
+    return response;
+}
+async function releaseVideoStatus(commandArgs, context) {
+    const values = parse(commandArgs, { "run-id": "string" });
+    const runId = requiredString(values["run-id"], "--run-id");
+    const jobResponse = await context.client.getJob({ jobId: runId });
+    return releaseVideoStatusFromJob(jobResponse, runId);
+}
+async function createReleaseVideoWithReattach(request, context) {
+    let attempt = 0;
+    let delayMs = RELEASE_VIDEO_REATTACH_INITIAL_DELAY_MS;
+    let sawDroppedCreate = false;
+    while (true) {
+        try {
+            return await context.client.createReleaseVideo(request);
+        }
+        catch (error) {
+            if (isRecoverableCreateWaitDrop(error)) {
+                if (attempt >= RELEASE_VIDEO_REATTACH_MAX_ATTEMPTS) {
+                    throw error;
+                }
+                attempt += 1;
+                sawDroppedCreate = true;
+                context.emitJsonlEvent?.({
+                    type: "wait_reconnect",
+                    command: "release-video.create",
+                    reason: "create_request_dropped"
+                });
+                continue;
+            }
+            if (sawDroppedCreate && isPendingIdempotencyReplayWithoutRunId(error)) {
+                if (attempt >= RELEASE_VIDEO_REATTACH_MAX_ATTEMPTS) {
+                    throw new errors_1.CliError("Release video run handle was not available before retry limit", {
+                        code: "release_video_reattach_timeout",
+                        exitCode: errors_1.EXIT_CODES.timeout,
+                        details: {
+                            attempts: attempt,
+                            reason: "idempotency_in_progress_without_run_id"
+                        }
+                    });
+                }
+                context.emitJsonlEvent?.({
+                    type: "wait_reconnect",
+                    command: "release-video.create",
+                    reason: "idempotency_in_progress_without_run_id",
+                    attempt: attempt + 1
+                });
+                await (context.sleep ?? defaultSleep)(delayMs);
+                delayMs = Math.min(delayMs * 2, RELEASE_VIDEO_REATTACH_MAX_DELAY_MS);
+                attempt += 1;
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+async function fileContentRequest(sourcePath) {
+    if (!sourcePath) {
+        return undefined;
+    }
+    return {
+        content: await (0, promises_1.readFile)(sourcePath, "utf8"),
+        fileName: node_path_1.default.basename(sourcePath),
+    };
+}
+function parse(commandArgs, options) {
+    try {
+        return (0, node_util_1.parseArgs)({
+            args: commandArgs,
+            allowPositionals: false,
+            strict: true,
+            options: Object.fromEntries(Object.entries(options).map(([name, type]) => [name, { type }]))
+        }).values;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new errors_1.CliError(message, { code: "invalid_arguments", exitCode: errors_1.EXIT_CODES.usage });
+    }
+}
+function requireProject(config) {
+    if (!config.projectId) {
+        throw new errors_1.CliError("Missing project id. Pass --project or set PDS_PROJECT_ID.", {
+            code: "missing_project",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    return config.projectId;
+}
+function requiredString(value, optionName) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new errors_1.CliError(`Missing required option ${optionName}`, { code: "missing_required_option", exitCode: errors_1.EXIT_CODES.usage });
+    }
+    return value;
+}
+function requiredRunOrJobId(values) {
+    const jobId = optionalString(values["job-id"]);
+    const runId = optionalString(values["run-id"]);
+    if (jobId && runId && jobId !== runId) {
+        throw new errors_1.CliError("Use only one of --job-id or --run-id", {
+            code: "conflicting_job_identifiers",
+            exitCode: errors_1.EXIT_CODES.usage,
+        });
+    }
+    return jobId ?? requiredString(runId, "--run-id");
+}
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function mutationIdempotencyKey(value, dryRun) {
+    if (dryRun) {
+        return optionalString(value);
+    }
+    return requiredString(value, "--idempotency-key");
+}
+function normalizeScriptTarget(value) {
+    if (value === "main" || value === "tts") {
+        return value;
+    }
+    throw new errors_1.CliError(`Unsupported script target: ${value}`, {
+        code: "invalid_script_target",
+        exitCode: errors_1.EXIT_CODES.usage,
+        details: {
+            supported: ["main", "tts"],
+        },
+    });
+}
+function readEnvelopeData(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    if (isRecord(value.data)) {
+        return value.data;
+    }
+    return value;
+}
+async function followAgentRunEvents(response, context) {
+    const runId = agentRunIdFromResponse(response);
+    if (!context.emitJsonlEvent || !runId) {
+        return;
+    }
+    await context.client.watchJob({
+        jobId: runId,
+        onEvent: context.emitJsonlEvent
+    });
+}
+async function waitForReleaseVideoRun(response, context) {
+    const runId = agentRunIdFromResponse(response);
+    if (!runId) {
+        return response;
+    }
+    let confirmations = 0;
+    const seenEvents = new Set();
+    const emitRunEvent = context.emitJsonlEvent
+        ? (event) => {
+            const eventKey = JSON.stringify(event);
+            if (seenEvents.has(eventKey)) {
+                return;
+            }
+            context.emitJsonlEvent?.(event);
+            seenEvents.add(eventKey);
+        }
+        : undefined;
+    while (true) {
+        await context.client.watchJob({
+            jobId: runId,
+            onEvent: emitRunEvent
+        });
+        const jobResponse = await context.client.getJob({ jobId: runId });
+        const run = readJobRun(jobResponse);
+        assertTerminalReleaseVideoRunSucceeded(run, runId);
+        const merged = mergeReleaseVideoRun(response, jobResponse);
+        if (isTerminalReleaseVideoRun(run)) {
+            return merged;
+        }
+        if (confirmations >= RELEASE_VIDEO_WAIT_MAX_CONFIRMATIONS) {
+            throw new errors_1.CliError("Release video run did not reach a terminal state before wait limit", {
+                code: "release_video_wait_timeout",
+                exitCode: errors_1.EXIT_CODES.timeout,
+                details: {
+                    runId,
+                    status: run ? optionalString(run.status) ?? null : null,
+                    confirmations
+                }
+            });
+        }
+        context.emitJsonlEvent?.({
+            type: "wait_reconnect",
+            command: "release-video.create",
+            reason: "event_stream_closed_before_terminal",
+            runId,
+            status: run ? optionalString(run.status) ?? null : null,
+            attempt: confirmations + 1
+        });
+        await (context.sleep ?? defaultSleep)(RELEASE_VIDEO_WAIT_POLL_MS);
+        confirmations += 1;
+    }
+}
+function agentRunIdFromResponse(value) {
+    const data = readEnvelopeData(value);
+    return (optionalString(data.runId) ??
+        runIdFromNested(data.agentRun) ??
+        runIdFromNested(data.pipeline, "run"));
+}
+function mergeReleaseVideoRun(response, jobResponse) {
+    const run = readJobRun(jobResponse);
+    if (!run || !isRecord(response)) {
+        return response;
+    }
+    const normalizedRun = {
+        ...run,
+        runId: optionalString(run.runId) ?? optionalString(run.id)
+    };
+    const data = readEnvelopeData(response);
+    if (!isRecord(data.pipeline)) {
+        return response;
+    }
+    const mergedData = {
+        ...data,
+        status: optionalString(normalizedRun.status) ?? optionalString(data.status) ?? "running",
+        pipeline: {
+            ...data.pipeline,
+            run: normalizedRun,
+            steps: Array.isArray(run.steps) ? run.steps : data.pipeline.steps,
+            terminalResult: run.terminalResult !== undefined
+                ? run.terminalResult
+                : data.pipeline.terminalResult
+        }
+    };
+    if (isRecord(response.data)) {
+        return {
+            ...response,
+            data: mergedData
+        };
+    }
+    return mergedData;
+}
+function releaseVideoStatusFromJob(jobResponse, fallbackRunId) {
+    const run = readJobRun(jobResponse);
+    if (!run) {
+        throw new errors_1.CliError("Agent job response did not include a run record", {
+            code: "invalid_agent_response",
+            exitCode: errors_1.EXIT_CODES.unexpected,
+            details: {
+                runId: fallbackRunId,
+            },
+        });
+    }
+    const runId = optionalString(run.runId) ?? optionalString(run.id) ?? fallbackRunId;
+    const normalizedRun = {
+        ...run,
+        runId,
+    };
+    const publicRun = publicReleaseVideoRun(normalizedRun);
+    const statusData = compact({
+        command: "release-video.status",
+        runId,
+        status: optionalString(publicRun.status),
+        projectId: optionalString(publicRun.projectId),
+        target: optionalString(publicRun.target),
+        pipeline: {
+            run: publicRun,
+            steps: Array.isArray(publicRun.steps) ? publicRun.steps : undefined,
+            terminalResult: publicRun.terminalResult,
+        },
+        summary: releaseVideoRunSummary(publicRun),
+    });
+    if (isRecord(jobResponse) && "ok" in jobResponse) {
+        return {
+            ...jobResponse,
+            data: statusData,
+        };
+    }
+    return {
+        ok: true,
+        data: statusData,
+    };
+}
+function publicReleaseVideoRun(run) {
+    const publicRun = {
+        ...run,
+    };
+    if (isRecord(run.error)) {
+        publicRun.error = publicReleaseVideoFailureError(run.error);
+    }
+    if (Array.isArray(run.steps)) {
+        publicRun.steps = run.steps.map((step) => {
+            if (!isRecord(step)) {
+                return step;
+            }
+            return {
+                ...step,
+                error: isRecord(step.error)
+                    ? publicReleaseVideoFailureError(step.error)
+                    : step.error,
+            };
+        });
+    }
+    return publicRun;
+}
+function releaseVideoRunSummary(run) {
+    const terminalResult = isRecord(run.terminalResult) ? run.terminalResult : {};
+    const youtubeUrl = readNestedString(terminalResult, ["publish", "publishStatus", "videoUrl"]) ??
+        readNestedString(terminalResult, ["summary", "youtubeUrl"]) ??
+        readNestedString(terminalResult, ["youtubeUrl"]);
+    const summary = compact({
+        youtubeUrl,
+    });
+    return Object.keys(summary).length > 0 ? summary : undefined;
+}
+function readNestedString(value, path) {
+    let cursor = value;
+    for (const segment of path) {
+        if (!isRecord(cursor)) {
+            return undefined;
+        }
+        cursor = cursor[segment];
+    }
+    return optionalString(cursor);
+}
+function readJobRun(value) {
+    const data = readEnvelopeData(value);
+    if (isRecord(data.run)) {
+        return data.run;
+    }
+    return null;
+}
+function assertTerminalReleaseVideoRunSucceeded(run, fallbackRunId) {
+    if (!run) {
+        return;
+    }
+    const status = optionalString(run.status);
+    if (!status || status === "succeeded") {
+        return;
+    }
+    if (status === "failed" || status === "cancelled" || status === "timed_out") {
+        const error = isRecord(run.error) ? run.error : null;
+        const publicError = publicReleaseVideoFailureError(error);
+        const terminalCode = status === "timed_out"
+            ? "timeout"
+            : status === "cancelled"
+                ? "cancelled"
+                : undefined;
+        const errorCode = optionalString(error?.code);
+        const code = terminalCode ??
+            errorCode ??
+            "agent_run_failed";
+        const message = errorCode === code
+            ? optionalString(error?.message) ?? releaseRunFailureMessage(status)
+            : releaseRunFailureMessage(status);
+        throw new errors_1.CliError(message, {
+            code,
+            exitCode: (0, errors_1.mapApiErrorToExitCode)(code, undefined),
+            details: compact({
+                runId: optionalString(run.runId) ?? optionalString(run.id) ?? fallbackRunId,
+                status,
+                failedStage: releaseVideoFailedStage(run),
+                logRef: releaseVideoFailureLogRef(run),
+                error: publicError
+            })
+        });
+    }
+}
+function isTerminalReleaseVideoRun(run) {
+    const status = run ? optionalString(run.status) : undefined;
+    return status === "succeeded" ||
+        status === "failed" ||
+        status === "cancelled" ||
+        status === "timed_out";
+}
+function releaseRunFailureMessage(status) {
+    if (status === "timed_out") {
+        return "Release video run timed out";
+    }
+    if (status === "cancelled") {
+        return "Release video run cancelled";
+    }
+    return "Release video run failed";
+}
+function releaseVideoFailedStage(run) {
+    const error = isRecord(run.error) ? run.error : null;
+    const details = isRecord(error?.details) ? error.details : null;
+    return optionalString(details?.failedStage) ?? failedStepStage(run);
+}
+function publicReleaseVideoFailureError(error) {
+    if (!error) {
+        return null;
+    }
+    const code = optionalString(error.code);
+    if (!isRecord(error.details)) {
+        return {
+            ...error,
+        };
+    }
+    return {
+        ...error,
+        details: publicReleaseVideoErrorDetails(code, error.details),
+    };
+}
+function publicReleaseVideoErrorDetails(code, details) {
+    const sanitized = sanitizeReleaseVideoInternalErrorDetails(details, code === "internal_error");
+    return isRecord(sanitized) ? sanitized : {};
+}
+function sanitizeReleaseVideoInternalErrorDetails(value, stripPrivateDetails) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeReleaseVideoInternalErrorDetails(item, stripPrivateDetails));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const nestedStripPrivateDetails = stripPrivateDetails || value.code === "internal_error";
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => !(nestedStripPrivateDetails &&
+        PRIVATE_INTERNAL_ERROR_DETAIL_KEY_PATTERN.test(key)))
+        .map(([key, entryValue]) => [
+        key,
+        sanitizeReleaseVideoInternalErrorDetails(entryValue, nestedStripPrivateDetails),
+    ]));
+}
+function releaseVideoFailureLogRef(run) {
+    const error = isRecord(run.error) ? run.error : null;
+    const details = isRecord(error?.details) ? error.details : null;
+    if (isRecord(details?.logRef)) {
+        return details.logRef;
+    }
+    const failedStage = failedStepStage(run);
+    const runId = optionalString(run.runId) ?? optionalString(run.id);
+    if (!failedStage || !runId) {
+        return undefined;
+    }
+    return {
+        runId,
+        stage: failedStage,
+    };
+}
+function failedStepStage(run) {
+    if (!Array.isArray(run.steps)) {
+        return undefined;
+    }
+    const failedStep = run.steps.find((step) => isRecord(step) && step.status === "failed");
+    return isRecord(failedStep)
+        ? optionalString(failedStep.id) ?? optionalString(failedStep.stage)
+        : undefined;
+}
+function isRecoverableCreateWaitDrop(error) {
+    if (error instanceof errors_1.CliError) {
+        return error.code === "network_error" || isClientTimeoutDrop(error);
+    }
+    return error instanceof TypeError || isTransportLikeError(error);
+}
+function isClientTimeoutDrop(error) {
+    return error.code === "timeout" &&
+        error.status === undefined &&
+        /^Request timed out after \d+ms$/.test(error.message);
+}
+function isTransportLikeError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /\b(socket|network|fetch|body|stream|connection|econnreset|terminated|aborted)\b/i.test(error.message);
+}
+function isPendingIdempotencyReplayWithoutRunId(error) {
+    if (!(error instanceof errors_1.CliError) || error.code !== "idempotency_key_reused") {
+        return false;
+    }
+    if (!isRecord(error.details)) {
+        return false;
+    }
+    return error.details.status === "in_progress" &&
+        optionalString(error.details.runId) === undefined;
+}
+function runIdFromNested(value, childKey) {
+    const record = childKey && isRecord(value) ? value[childKey] : value;
+    if (!isRecord(record)) {
+        return undefined;
+    }
+    return optionalString(record.runId);
+}
+function isPendingDeviceAuthorization(error) {
+    return (error instanceof errors_1.CliError &&
+        error.code === "auth_required" &&
+        isRecord(error.details) &&
+        error.details.reason === "device_authorization_pending");
+}
+function readPendingIntervalSeconds(error) {
+    return isRecord(error.details) ? error.details.intervalSeconds : undefined;
+}
+function readExpiryMs(value) {
+    const expiresAt = typeof value === "string" ? Date.parse(value) : Number.NaN;
+    if (Number.isFinite(expiresAt)) {
+        return expiresAt;
+    }
+    return Date.now() + 10 * 60 * 1000;
+}
+function readIntervalMs(value, fallbackMs) {
+    const numeric = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(numeric)) {
+        return fallbackMs;
+    }
+    return Math.max(0, Math.round(numeric * 1000));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function ensureNoCommandArgs(commandArgs) {
+    if (commandArgs.length > 0) {
+        throw new errors_1.CliError(`Unexpected arguments: ${commandArgs.join(" ")}`, { code: "invalid_arguments", exitCode: errors_1.EXIT_CODES.usage });
+    }
+}
+function resolveExpiryIso(expiresAt, expiresIn) {
+    if (expiresAt) {
+        const parsed = Date.parse(expiresAt);
+        if (!Number.isFinite(parsed)) {
+            throw new errors_1.CliError(`Invalid --expires-at value: ${expiresAt}`, { code: "invalid_expiry", exitCode: errors_1.EXIT_CODES.usage });
+        }
+        return new Date(parsed).toISOString();
+    }
+    const durationMs = parseExtendedDurationMs(expiresIn);
+    return new Date(Date.now() + durationMs).toISOString();
+}
+function parseExtendedDurationMs(value) {
+    const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/.exec(value.trim());
+    if (!match) {
+        throw new errors_1.CliError(`Invalid duration: ${value}`, { code: "invalid_duration", exitCode: errors_1.EXIT_CODES.usage });
+    }
+    const amount = Number(match[1]);
+    const unit = match[2] ?? "ms";
+    const multipliers = {
+        ms: 1,
+        s: 1000,
+        m: 60_000,
+        h: 60 * 60_000,
+        d: 24 * 60 * 60_000
+    };
+    const durationMs = Math.round(amount * multipliers[unit]);
+    if (!Number.isFinite(durationMs) || durationMs <= 0) {
+        throw new errors_1.CliError(`Invalid duration: ${value}`, { code: "invalid_duration", exitCode: errors_1.EXIT_CODES.usage });
+    }
+    return durationMs;
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=registry.js.map