@git.zone/tsdeploy 0.2.0 → 0.4.0

package/dist_ts/classes.tsdeploy.js

@@ -1,6 +1,12 @@
 import * as plugins from './plugins.js';
 const schemaVersion = 1;
 const profileNameRegex = /^[a-zA-Z0-9._-]+$/;
+const defaultPlatform = 'linux/amd64';
+const defaultCloudlyRequestTimeoutMs = 30000;
+const defaultCommandTimeoutMs = 30 * 60 * 1000;
+const dockerCommandTimeoutMs = 60 * 60 * 1000;
+const defaultMaxCommandOutputBytes = 1024 * 1024;
+const defaultVerifyUrlTimeoutMs = 15000;
 const normalizeProfileName = (profileArg) => {
     const profile = profileArg.trim();
     if (!profile || !profileNameRegex.test(profile)) {
@@ -29,9 +35,15 @@ export const redactProfile = (profileArg) => {
 export class TsDeploy {
     projectDir;
     profileStore;
+    env;
+    commandRunner;
+    cloudlyRequest;
     constructor(optionsArg = {}) {
         this.projectDir = plugins.path.resolve(optionsArg.projectDir ?? process.cwd());
         this.profileStore = this.createProfileStore(optionsArg);
+        this.env = optionsArg.env ?? process.env;
+        this.commandRunner = optionsArg.commandRunner ?? this.defaultCommandRunner;
+        this.cloudlyRequest = optionsArg.cloudlyRequest ?? this.defaultCloudlyRequest;
     }
     get projectLinkPath() {
         return plugins.path.join(this.projectDir, '.nogit', 'tsdeploy.json');
@@ -145,7 +157,7 @@ export class TsDeploy {
             warnings.push(`Profile "${activeProfile}" is not configured. Run tsdeploy login --profile ${activeProfile}.`);
         }
         if (profile && !profile.token) {
-            warnings.push(`Profile "${profile.name}" has no token. Remote deploy mutations remain unavailable.`);
+            warnings.push(`Profile "${profile.name}" has no token. Cloudly deploy requires a token or username/password at deploy time.`);
         }
         return {
             projectDir: this.projectDir,
@@ -159,11 +171,19 @@ export class TsDeploy {
     async buildPlan() {
         const status = await this.getStatus();
         const actions = [];
+        const canDeployCloudly = Boolean(status.projectLink?.serviceId && status.profile?.target === 'cloudly');
         if (status.projectLink && status.profile) {
             actions.push({
                 type: 'inspect',
                 title: 'Inspect linked deployment',
-                description: 'Resolve the linked Cloudly/Onebox deployment and compare desired app metadata once typed deployment APIs are verified.',
+                description: 'Resolve the linked Cloudly service and registry target before deploying.',
+            });
+            actions.push({
+                type: canDeployCloudly ? 'deploy' : 'noop',
+                title: canDeployCloudly ? 'Deploy Cloudly workload image' : 'Deployment link incomplete or unsupported',
+                description: canDeployCloudly
+                    ? 'Run project checks, build and push the linked OCI image, and let Cloudly deployOnPush reconcile the service.'
+                    : 'Cloudly workload deploy requires a serviceId; Onebox deployment mutations are not implemented yet.',
             });
         }
         else {
@@ -173,16 +193,13 @@ export class TsDeploy {
                 description: 'Create a profile and project link before a deployment plan can inspect remote state.',
             });
         }
-        actions.push({
-            type: 'noop',
-            title: 'Deployment mutation disabled',
-            description: 'tsdeploy MVP does not install, update, or upgrade apps until Cloudly/Onebox deployment contracts are verified upstream.',
-        });
         return {
             schemaVersion,
             projectDir: this.projectDir,
-            mutationAllowed: false,
-            summary: 'Safe planning only: no remote deployment mutations will be executed.',
+            mutationAllowed: canDeployCloudly,
+            summary: canDeployCloudly
+                ? 'Cloudly workload deploy is available through registry push and deployOnPush reconciliation.'
+                : 'Safe planning only: no remote deployment mutations will be executed.',
             profile: status.activeProfile,
             deploymentId: status.projectLink?.deploymentId,
             serviceId: status.projectLink?.serviceId,
@@ -206,7 +223,9 @@ export class TsDeploy {
             {
                 name: 'remote-mutations',
                 ok: true,
-                message: 'Remote deployment mutations are intentionally disabled in this MVP.',
+                message: status.profile?.target === 'cloudly'
+                    ? 'Cloudly workload deployment is available with deploy-time Cloudly credentials.'
+                    : 'Only Cloudly workload deployment is implemented currently.',
             },
         ];
         return {
@@ -215,5 +234,515 @@ export class TsDeploy {
             warnings: status.warnings,
         };
     }
+    async deploy(optionsArg = {}) {
+        const status = await this.getStatus();
+        const projectLink = status.projectLink;
+        const profile = await this.getProfile(projectLink?.profile ?? status.activeProfile);
+        const steps = [];
+        const warnings = [];
+        const tag = optionsArg.tag || 'latest';
+        const platform = optionsArg.platform || defaultPlatform;
+        const waitSeconds = optionsArg.waitSeconds ?? 0;
+        if (!projectLink) {
+            throw new Error('No .nogit/tsdeploy.json project link found. Run tsdeploy link first.');
+        }
+        if (!projectLink.serviceId) {
+            throw new Error('Project link has no serviceId. Run tsdeploy link --serviceId <id>.');
+        }
+        if (!profile) {
+            throw new Error(`Profile "${projectLink.profile}" is not configured. Run tsdeploy login --profile ${projectLink.profile}.`);
+        }
+        if (profile.target !== 'cloudly') {
+            throw new Error(`Deploy target "${profile.target}" is not implemented. Only Cloudly workload deployment is supported.`);
+        }
+        const deploySecretValues = this.collectSecretValues(undefined, [
+            profile.token,
+            optionsArg.token,
+            optionsArg.password,
+            this.env.TSDEPLOY_TOKEN,
+            this.env.TSDEPLOY_CLOUDLY_PASSWORD,
+            this.env.CLOUDLY_PASSWORD,
+        ]);
+        const localConfig = await this.readProjectSmartconfig();
+        const localImage = this.resolveLocalDockerImage(localConfig, tag);
+        let image = optionsArg.image || localImage;
+        if (optionsArg.dryRun) {
+            if (!image) {
+                image = '<resolved-from-cloudly-service-registry-target>';
+                warnings.push('Dry run did not contact Cloudly, so the final image URL was not resolved.');
+            }
+            steps.push({ name: 'cloudly-preflight', status: 'skipped', message: 'Dry run skipped Cloudly service validation.' });
+            steps.push({ name: 'checks', status: 'skipped', message: 'Dry run skipped project checks.' });
+            steps.push({ name: 'docker-buildx-push', status: 'skipped', message: `Dry run would push ${image}.` });
+            return {
+                schemaVersion,
+                projectDir: this.projectDir,
+                profile: profile.name,
+                serviceId: projectLink.serviceId,
+                deploymentId: projectLink.deploymentId,
+                dryRun: true,
+                image,
+                tag,
+                platform,
+                pushed: false,
+                triggered: false,
+                verified: false,
+                deployments: [],
+                steps,
+                warnings,
+            };
+        }
+        const identity = await this.resolveCloudlyIdentity(profile, optionsArg);
+        steps.push({ name: 'cloudly-auth', status: 'passed', message: 'Cloudly identity resolved.' });
+        const service = await this.fireCloudlyRequest(profile.origin, 'getServiceById', { identity, serviceId: projectLink.serviceId }).then(response => response.service);
+        if (service.data.deployOnPush === false) {
+            throw new Error(`Service "${service.data.name}" has deployOnPush disabled; refusing to push an image that Cloudly will not deploy.`);
+        }
+        const registryTarget = await this.fireCloudlyRequest(profile.origin, 'getServiceRegistryTarget', { identity, serviceId: projectLink.serviceId, tag }).then(response => response.registryTarget);
+        if (!registryTarget.imageUrl) {
+            throw new Error('Cloudly did not return a registry target image URL for the linked service.');
+        }
+        if (optionsArg.image && optionsArg.image !== registryTarget.imageUrl) {
+            throw new Error(`Requested image "${optionsArg.image}" does not match Cloudly registry target "${registryTarget.imageUrl}".`);
+        }
+        image = registryTarget.imageUrl;
+        if (localImage && localImage !== image) {
+            warnings.push(`Local .smartconfig Docker image "${localImage}" differs from Cloudly registry target "${image}". Using Cloudly target.`);
+        }
+        steps.push({ name: 'cloudly-preflight', status: 'passed', message: `Validated service "${service.data.name}" and registry target.` });
+        if (!optionsArg.skipPush) {
+            await this.ensureCleanGitWorktree(steps, Boolean(optionsArg.allowDirty));
+        }
+        if (optionsArg.skipChecks) {
+            steps.push({ name: 'checks', status: 'skipped', message: 'Project checks skipped by option.' });
+        }
+        else {
+            const checkCommand = await this.resolveProjectCheckCommand();
+            if (checkCommand) {
+                await this.runCheckedCommand({
+                    command: checkCommand.command,
+                    args: checkCommand.args,
+                    cwd: this.projectDir,
+                    env: this.env,
+                    timeoutMs: defaultCommandTimeoutMs,
+                    maxOutputBytes: defaultMaxCommandOutputBytes,
+                }, 'checks', steps, deploySecretValues);
+            }
+            else {
+                steps.push({ name: 'checks', status: 'skipped', message: 'No test or build script found in package.json.' });
+            }
+        }
+        let digest;
+        if (optionsArg.skipPush) {
+            steps.push({ name: 'docker-buildx-push', status: 'skipped', message: 'Docker push skipped by option.' });
+        }
+        else {
+            const buildEnv = await this.resolveDockerBuildEnv(localConfig);
+            const buildArgs = Object.keys(buildEnv.buildArgValues);
+            const dockerArgs = [
+                'buildx',
+                'build',
+                ...(optionsArg.builder ? ['--builder', optionsArg.builder] : []),
+                '--platform',
+                platform,
+                '--provenance=false',
+                '--sbom=false',
+                ...buildArgs.flatMap(buildArg => ['--build-arg', buildArg]),
+                '-t',
+                image,
+                '--push',
+                '.',
+            ];
+            const commandResult = await this.runCheckedCommand({
+                command: 'docker',
+                args: dockerArgs,
+                cwd: this.projectDir,
+                env: {
+                    ...this.env,
+                    ...buildEnv.buildArgValues,
+                },
+                timeoutMs: dockerCommandTimeoutMs,
+                maxOutputBytes: defaultMaxCommandOutputBytes,
+            }, 'docker-buildx-push', steps, [...deploySecretValues, ...buildEnv.secretValues]);
+            digest = this.extractDigest(`${commandResult.stdout}\n${commandResult.stderr}`);
+        }
+        let deployments = await this.getCloudlyDeployments(profile.origin, identity, projectLink.serviceId);
+        if (waitSeconds > 0) {
+            deployments = await this.waitForHealthyDeployment(profile.origin, identity, projectLink.serviceId, waitSeconds);
+        }
+        let verifyStatus;
+        if (optionsArg.verifyUrl) {
+            verifyStatus = await this.verifyUrl(optionsArg.verifyUrl);
+            steps.push({
+                name: 'verify-url',
+                status: verifyStatus >= 200 && verifyStatus < 400 ? 'passed' : 'failed',
+                message: `${optionsArg.verifyUrl} returned HTTP ${verifyStatus}.`,
+            });
+            if (verifyStatus < 200 || verifyStatus >= 400) {
+                throw new Error(`Verification URL returned HTTP ${verifyStatus}: ${optionsArg.verifyUrl}`);
+            }
+        }
+        return {
+            schemaVersion,
+            projectDir: this.projectDir,
+            profile: profile.name,
+            serviceId: projectLink.serviceId,
+            deploymentId: projectLink.deploymentId,
+            dryRun: false,
+            image,
+            tag,
+            platform,
+            pushed: !optionsArg.skipPush,
+            triggered: !optionsArg.skipPush,
+            verified: Boolean(optionsArg.verifyUrl && verifyStatus && verifyStatus >= 200 && verifyStatus < 400),
+            digest,
+            verifyStatus,
+            service: {
+                serviceId: service.id,
+                serviceName: service.data.name,
+                deployOnPush: true,
+                registryTarget: {
+                    registryHost: registryTarget.registryHost,
+                    repository: registryTarget.repository,
+                    tag: registryTarget.tag,
+                    imageUrl: registryTarget.imageUrl,
+                },
+            },
+            deployments,
+            steps,
+            warnings,
+        };
+    }
+    defaultCommandRunner = async (optionsArg) => {
+        return await new Promise((resolve, reject) => {
+            const timeoutMs = optionsArg.timeoutMs ?? defaultCommandTimeoutMs;
+            const maxOutputBytes = optionsArg.maxOutputBytes ?? defaultMaxCommandOutputBytes;
+            const child = plugins.childProcess.spawn(optionsArg.command, optionsArg.args, {
+                cwd: optionsArg.cwd,
+                env: {
+                    ...process.env,
+                    ...optionsArg.env,
+                },
+                detached: process.platform !== 'win32',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            let stdoutBytes = 0;
+            let stderrBytes = 0;
+            let stdoutTruncated = false;
+            let stderrTruncated = false;
+            let timedOut = false;
+            let timeoutRef;
+            let killTimeoutRef;
+            const appendOutput = (chunksArg, chunkArg, bytesArg) => {
+                const bytes = bytesArg + chunkArg.length;
+                const remainingBytes = maxOutputBytes - bytesArg;
+                if (remainingBytes > 0) {
+                    chunksArg.push(chunkArg.subarray(0, remainingBytes));
+                }
+                return { bytes, truncated: bytes > maxOutputBytes };
+            };
+            child.stdout?.on('data', chunkArg => {
+                const result = appendOutput(stdoutChunks, Buffer.from(chunkArg), stdoutBytes);
+                stdoutBytes = result.bytes;
+                stdoutTruncated ||= result.truncated;
+            });
+            child.stderr?.on('data', chunkArg => {
+                const result = appendOutput(stderrChunks, Buffer.from(chunkArg), stderrBytes);
+                stderrBytes = result.bytes;
+                stderrTruncated ||= result.truncated;
+            });
+            const clearTimers = (clearKillTimerArg = true) => {
+                if (timeoutRef)
+                    clearTimeout(timeoutRef);
+                if (clearKillTimerArg && killTimeoutRef)
+                    clearTimeout(killTimeoutRef);
+            };
+            const killProcess = (signalArg) => {
+                if (process.platform !== 'win32' && child.pid) {
+                    try {
+                        process.kill(-child.pid, signalArg);
+                        return;
+                    }
+                    catch {
+                        // Fall back to direct child termination below.
+                    }
+                }
+                child.kill(signalArg);
+            };
+            timeoutRef = setTimeout(() => {
+                timedOut = true;
+                killProcess('SIGTERM');
+                killTimeoutRef = setTimeout(() => {
+                    killProcess('SIGKILL');
+                }, 10000);
+                killTimeoutRef.unref?.();
+            }, timeoutMs);
+            timeoutRef.unref?.();
+            child.on('error', errorArg => {
+                clearTimers(!timedOut);
+                reject(errorArg);
+            });
+            child.on('close', exitCode => {
+                clearTimers(!timedOut);
+                if (stdoutTruncated) {
+                    stdoutChunks.push(Buffer.from('\n[tsdeploy: stdout truncated]\n'));
+                }
+                if (stderrTruncated) {
+                    stderrChunks.push(Buffer.from('\n[tsdeploy: stderr truncated]\n'));
+                }
+                if (timedOut) {
+                    stderrChunks.push(Buffer.from(`\n[tsdeploy: command timed out after ${timeoutMs}ms]\n`));
+                }
+                resolve({
+                    command: optionsArg.command,
+                    args: optionsArg.args,
+                    exitCode: timedOut ? 124 : exitCode ?? 1,
+                    stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                    stderr: Buffer.concat(stderrChunks).toString('utf8'),
+                });
+            });
+        });
+    };
+    defaultCloudlyRequest = async (originArg, methodArg, requestArg) => {
+        const controller = new AbortController();
+        const timeoutRef = setTimeout(() => controller.abort(), defaultCloudlyRequestTimeoutMs);
+        timeoutRef.unref?.();
+        try {
+            const response = await fetch(`${originArg.replace(/\/+$/, '')}/typedrequest`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({
+                    method: methodArg,
+                    request: requestArg,
+                    response: {},
+                    correlation: {
+                        id: plugins.crypto.randomUUID(),
+                        phase: 'request',
+                    },
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                await response.body?.cancel().catch(() => undefined);
+                throw new Error(`Cloudly request "${methodArg}" failed with HTTP ${response.status}.`);
+            }
+            const payload = await response.json();
+            if (payload.error) {
+                throw new plugins.typedrequest.TypedResponseError(payload.error.text, payload.error.data);
+            }
+            if (payload.retry) {
+                throw new Error(`Cloudly request "${methodArg}" requested retry after ${payload.retry.waitForMs}ms: ${payload.retry.reason}`);
+            }
+            return payload.response;
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                throw new Error(`Cloudly request "${methodArg}" timed out after ${defaultCloudlyRequestTimeoutMs}ms.`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutRef);
+        }
+    };
+    async fireCloudlyRequest(originArg, methodArg, requestArg) {
+        return await this.cloudlyRequest(originArg, methodArg, requestArg);
+    }
+    async resolveCloudlyIdentity(profileArg, optionsArg) {
+        const username = optionsArg.username || this.env.TSDEPLOY_CLOUDLY_USERNAME || this.env.CLOUDLY_USERNAME;
+        const password = optionsArg.password || this.env.TSDEPLOY_CLOUDLY_PASSWORD || this.env.CLOUDLY_PASSWORD;
+        if (username && password) {
+            const response = await this.fireCloudlyRequest(profileArg.origin, 'adminLoginWithUsernameAndPassword', { username, password });
+            return response.identity;
+        }
+        const token = optionsArg.token || this.env.TSDEPLOY_TOKEN || profileArg.token;
+        if (token) {
+            const response = await this.fireCloudlyRequest(profileArg.origin, 'getIdentityByToken', { token });
+            return response.identity;
+        }
+        throw new Error('Cloudly credentials are required for deploy. Provide --token, TSDEPLOY_TOKEN, profile token, or TSDEPLOY_CLOUDLY_USERNAME/TSDEPLOY_CLOUDLY_PASSWORD.');
+    }
+    async readProjectSmartconfig() {
+        try {
+            const raw = await plugins.fs.readFile(plugins.path.join(this.projectDir, '.smartconfig.json'), 'utf8');
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return {};
+            throw error;
+        }
+    }
+    async readProjectPackageJson() {
+        try {
+            const raw = await plugins.fs.readFile(plugins.path.join(this.projectDir, 'package.json'), 'utf8');
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return {};
+            throw error;
+        }
+    }
+    resolveLocalDockerImage(configArg, tagArg) {
+        const dockerConfig = configArg['@git.zone/tsdocker'];
+        const registries = Array.isArray(dockerConfig?.registries) ? dockerConfig.registries : [];
+        const registryRepoMap = dockerConfig?.registryRepoMap ?? {};
+        const registryHost = registries[0] ?? Object.keys(registryRepoMap)[0];
+        const repository = registryHost ? registryRepoMap[registryHost] : undefined;
+        if (!registryHost || !repository)
+            return undefined;
+        return `${registryHost}/${repository}:${tagArg}`;
+    }
+    async resolveProjectCheckCommand() {
+        const packageJson = await this.readProjectPackageJson();
+        if (packageJson.scripts?.test) {
+            return { command: 'pnpm', args: ['test'] };
+        }
+        if (packageJson.scripts?.build) {
+            return { command: 'pnpm', args: ['run', 'build'] };
+        }
+        return undefined;
+    }
+    async ensureCleanGitWorktree(stepsArg, allowDirtyArg) {
+        if (allowDirtyArg) {
+            stepsArg.push({ name: 'git-worktree', status: 'skipped', message: 'Dirty worktree check skipped by option.' });
+            return;
+        }
+        const result = await this.commandRunner({
+            command: 'git',
+            args: ['status', '--porcelain'],
+            cwd: this.projectDir,
+            env: this.env,
+            timeoutMs: 30000,
+            maxOutputBytes: 128 * 1024,
+        });
+        if (result.exitCode !== 0) {
+            stepsArg.push({ name: 'git-worktree', status: 'failed', message: 'Git status check failed.' });
+            throw new Error('Refusing to deploy because the project is not a readable git working tree. Commit the project first or pass --allowDirty.');
+        }
+        const dirtyOutput = result.stdout.trim();
+        if (dirtyOutput) {
+            stepsArg.push({ name: 'git-worktree', status: 'failed', message: 'Uncommitted changes are present.' });
+            throw new Error(`Refusing to deploy with uncommitted changes:\n${dirtyOutput}\nCommit the project first or pass --allowDirty.`);
+        }
+        stepsArg.push({ name: 'git-worktree', status: 'passed', message: 'Git working tree is clean.' });
+    }
+    async resolveDockerBuildEnv(configArg) {
+        const dockerConfig = configArg['@git.zone/tsdocker'] ?? {};
+        const szciConfig = configArg['@ship.zone/szci'] ?? {};
+        const buildArgEnvMap = {
+            ...(dockerConfig.buildArgEnvMap ?? {}),
+            ...(szciConfig.dockerBuildargEnvMap ?? {}),
+        };
+        const buildArgValues = {};
+        const secretValues = [];
+        for (const [buildArg, envName] of Object.entries(buildArgEnvMap)) {
+            const value = this.env[envName];
+            if (!value) {
+                throw new Error(`Missing required Docker build arg environment value: ${envName}`);
+            }
+            buildArgValues[buildArg] = value;
+            secretValues.push(value);
+        }
+        return { buildArgValues, secretValues };
+    }
+    async runCheckedCommand(commandArg, stepNameArg, stepsArg, secretValuesArg) {
+        const result = await this.commandRunner(commandArg);
+        if (result.exitCode !== 0) {
+            stepsArg.push({ name: stepNameArg, status: 'failed', message: `${commandArg.command} exited with code ${result.exitCode}.` });
+            const output = this.redactText(`${result.stdout}\n${result.stderr}`, this.collectSecretValues(commandArg.env, secretValuesArg));
+            throw new Error(`${commandArg.command} failed with exit code ${result.exitCode}:\n${output}`.trim());
+        }
+        stepsArg.push({ name: stepNameArg, status: 'passed', message: `${commandArg.command} completed successfully.` });
+        return result;
+    }
+    collectSecretValues(envArg, additionalValuesArg = []) {
+        const values = new Set();
+        const addValue = (valueArg) => {
+            if (valueArg && valueArg.length >= 4)
+                values.add(valueArg);
+        };
+        for (const value of additionalValuesArg)
+            addValue(value);
+        if (envArg) {
+            for (const [key, value] of Object.entries(envArg)) {
+                if (/(token|password|secret|credential|private|auth|key)/i.test(key)) {
+                    addValue(value);
+                }
+            }
+        }
+        return [...values];
+    }
+    redactText(textArg, secretValuesArg) {
+        let result = textArg;
+        for (const secret of secretValuesArg.filter(Boolean)) {
+            result = result.split(secret).join('[redacted]');
+        }
+        return result;
+    }
+    extractDigest(outputArg) {
+        const preferredPatterns = [
+            /pushing manifest for .+@(sha256:[a-f0-9]{64})/gi,
+            /exporting manifest list (sha256:[a-f0-9]{64})/gi,
+            /exporting manifest (sha256:[a-f0-9]{64})/gi,
+        ];
+        for (const pattern of preferredPatterns) {
+            const matches = [...outputArg.matchAll(pattern)];
+            const digest = matches.at(-1)?.[1];
+            if (digest)
+                return digest;
+        }
+        return [...outputArg.matchAll(/sha256:[a-f0-9]{64}/gi)].at(-1)?.[0];
+    }
+    async getCloudlyDeployments(originArg, identityArg, serviceIdArg) {
+        const response = await this.fireCloudlyRequest(originArg, 'getDeploymentsByService', { identity: identityArg, serviceId: serviceIdArg });
+        return response.deployments.map(deployment => ({
+            deploymentId: deployment.id,
+            serviceId: deployment.serviceId,
+            serviceName: deployment.serviceName,
+            status: deployment.status,
+            healthStatus: deployment.healthStatus,
+            nodeName: deployment.nodeName,
+            version: deployment.version,
+            containerId: deployment.containerId,
+            deployedAt: deployment.deployedAt,
+            updatedAt: deployment.updatedAt,
+        }));
+    }
+    async waitForHealthyDeployment(originArg, identityArg, serviceIdArg, waitSecondsArg) {
+        const deadline = Date.now() + waitSecondsArg * 1000;
+        let deployments = [];
+        while (Date.now() <= deadline) {
+            deployments = await this.getCloudlyDeployments(originArg, identityArg, serviceIdArg);
+            if (deployments.some(deployment => deployment.status === 'running' && deployment.healthStatus === 'healthy')) {
+                return deployments;
+            }
+            await new Promise(resolve => setTimeout(resolve, 5000));
+        }
+        throw new Error(`No healthy running deployment observed for service ${serviceIdArg} within ${waitSecondsArg}s.`);
+    }
+    async verifyUrl(urlArg) {
+        const controller = new AbortController();
+        const timeoutRef = setTimeout(() => controller.abort(), defaultVerifyUrlTimeoutMs);
+        timeoutRef.unref?.();
+        try {
+            const response = await fetch(urlArg, { method: 'HEAD', signal: controller.signal });
+            return response.status;
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                throw new Error(`Verification URL timed out after ${defaultVerifyUrlTimeoutMs}ms: ${urlArg}`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutRef);
+        }
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tsdeploy.js","sourceRoot":"","sources":["../ts/classes.tsdeploy.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tsdeploy.js","sourceRoot":"","sources":["../ts/classes.tsdeploy.ts"],"names":[],"mappings":"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"}