devchain-cli 0.23.4 → 0.24.1

package/dist/server/modules/remotes/operations/remote-host.client.js

@@ -0,0 +1,772 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteHostClient = exports.RemoteHostRequestError = void 0;
+exports.dialAddress = dialAddress;
+const remote_api_key_service_1 = require("../auth/remote-api-key.service");
+const shared_1 = require("@devchain/shared");
+const node_stream_1 = require("node:stream");
+const docker_engine_client_1 = require("../../core/controllers/docker-engine.client");
+const host_docker_dto_1 = require("../host/host-docker.dto");
+const transcript_files_service_1 = require("../transcripts/transcript-files.service");
+const transcript_transfer_dto_1 = require("../transcripts/transcript-transfer.dto");
+const common_1 = require("@nestjs/common");
+const zod_1 = require("zod");
+const shared_2 = require("@devchain/shared");
+const env_config_1 = require("../../../common/config/env.config");
+const error_types_1 = require("../../../common/errors/error-types");
+const storage_interface_1 = require("../../storage/interfaces/storage.interface");
+const project_time_settler_service_1 = require("../time/project-time-settler.service");
+const file_sync_dto_1 = require("../../file-sync/file-sync.dto");
+const file_sync_service_1 = require("../../file-sync/file-sync.service");
+const docker_runtime_1 = require("../../core/controllers/docker-runtime");
+const host_helper_service_1 = require("../host/host-helper.service");
+const remote_address_1 = require("../remote-address");
+const remote_tls_1 = require("../transport/remote-tls");
+const remote_discovery_1 = require("../transport/remote-discovery");
+const CONTROL_TIMEOUT_MS = 15_000;
+const REPLICA_TIMEOUT_MS = 120_000;
+const RUNTIME_TIMEOUT_MS = 5_000;
+const CLAIM_TIMEOUT_MS = 45 * 60_000;
+const VERIFY_TIMEOUT_MS = 100_000;
+const HostRuntimeSchema = zod_1.z
+    .object({
+    state: zod_1.z.string().optional(),
+    bootId: zod_1.z.string().optional(),
+    docker: docker_runtime_1.DockerRuntimeSchema.optional(),
+    version: zod_1.z.string().nullable().optional(),
+    homePath: zod_1.z.string().nullable().optional(),
+    uid: zod_1.z.number().nullable().optional(),
+    gid: zod_1.z.number().nullable().optional(),
+    imageVersion: zod_1.z.string().nullable().optional(),
+    cliVersions: zod_1.z.record(zod_1.z.string()).nullable().optional(),
+})
+    .passthrough();
+const HostProviderVerifySchema = zod_1.z.object({
+    ok: zod_1.z.boolean(),
+    summary: zod_1.z.string(),
+    hint: zod_1.z.string().nullable(),
+});
+const HostUpdateStatusBodySchema = zod_1.z.object({
+    status: host_helper_service_1.HostUpdateStatusSchema.omit({ at: true }).passthrough().nullable(),
+});
+const FrozenProjectSchema = zod_1.z.object({
+    projectId: zod_1.z.string(),
+    frozenAt: zod_1.z.string(),
+});
+const EpicIdSchema = zod_1.z.object({ epicId: zod_1.z.string().min(1) });
+const CreatedEpicSchema = zod_1.z.object({ id: zod_1.z.string().min(1) });
+class RemoteHostRequestError extends error_types_1.AppError {
+    constructor(message, details) {
+        super(message, 'REMOTE_HOST_REQUEST_FAILED', 502, details);
+    }
+    get status() {
+        return this.details?.status ?? null;
+    }
+}
+exports.RemoteHostRequestError = RemoteHostRequestError;
+let RemoteHostClient = class RemoteHostClient {
+    storage;
+    apiKeys;
+    constructor(storage, apiKeys) {
+        this.storage = storage;
+        this.apiKeys = apiKeys;
+    }
+    async dockerClient(remoteId, options) {
+        const remote = await this.storage.getRemote(remoteId);
+        const { baseUrl, certificate } = (0, remote_tls_1.requireRemoteTls)(remote);
+        return docker_engine_client_1.DockerEngineClient.forHttp(baseUrl, (0, remote_tls_1.pinnedTlsOptions)(certificate), {
+            ...(await this.apiKeys.headers(remoteId)),
+            ...(options.apiVersion ? { [host_docker_dto_1.DOCKER_API_VERSION_HEADER]: options.apiVersion } : {}),
+        });
+    }
+    async dockerCall(remoteId, options, action) {
+        try {
+            return await action(await this.dockerClient(remoteId, options));
+        }
+        catch (error) {
+            throw new RemoteHostRequestError('Docker host request failed', {
+                remoteId,
+                path: '/api/host/docker',
+                status: error instanceof docker_engine_client_1.DockerEngineError ? (error.status ?? null) : null,
+                hostCode: error instanceof docker_engine_client_1.DockerEngineError ? error.code : null,
+            });
+        }
+    }
+    dockerJson(remoteId, method, path, body, options) {
+        return this.dockerCall(remoteId, options, (client) => client.json(method, path, body, { signal: options.signal }));
+    }
+    dockerScan(remoteId, paths, options = {}, volumes) {
+        return this.dockerJson(remoteId, 'POST', '/api/host/docker/scan', { paths, ...(volumes && { volumes }) }, options);
+    }
+    dockerCapacity(remoteId, paths, options = {}) {
+        return this.dockerJson(remoteId, 'POST', '/api/host/docker/capacity', { paths }, options);
+    }
+    dockerImagesPresent(remoteId, ids, options = {}) {
+        return this.dockerJson(remoteId, 'POST', '/api/host/docker/images/present', { ids }, options);
+    }
+    dockerCreateVolume(remoteId, input, options = {}) {
+        return this.dockerJson(remoteId, 'POST', '/api/host/docker/volumes', input, options);
+    }
+    dockerCreateNetwork(remoteId, input, options = {}) {
+        return this.dockerJson(remoteId, 'POST', '/api/host/docker/networks', input, options);
+    }
+    dockerCreateContainer(remoteId, input, options = {}) {
+        return this.dockerJson(remoteId, 'POST', '/api/host/docker/containers', input, options);
+    }
+    dockerVolumeHolders(remoteId, name, options = {}) {
+        return this.dockerJson(remoteId, 'GET', `/api/host/docker/volumes/${enc(name)}/holders`, undefined, options);
+    }
+    dockerDelete(remoteId, kind, id, projectId, options = {}) {
+        return this.dockerJson(remoteId, 'DELETE', `/api/host/docker/${kind}/${enc(id)}?${new URLSearchParams({ projectId })}`, undefined, options);
+    }
+    dockerSaveImage(remoteId, id, options = {}) {
+        return this.dockerCall(remoteId, options, (client) => client.stream('GET', `/api/host/docker/images/${enc(id)}/archive`, {
+            signal: options.signal,
+        }));
+    }
+    async dockerReadArchive(remoteId, input, options = {}) {
+        let sha256 = null;
+        const archive = await this.dockerCall(remoteId, options, (client) => client.stream('GET', `/api/host/docker/archive?${new URLSearchParams(input)}`, {
+            signal: options.signal,
+            onTrailers: (trailers) => {
+                const value = trailers[host_docker_dto_1.DOCKER_ARCHIVE_SHA256_TRAILER];
+                sha256 = value && /^[0-9a-f]{64}$/.test(value) ? value : null;
+            },
+        }));
+        return { archive, sha256: () => sha256 };
+    }
+    dockerStopContainer(remoteId, id, projectId, options = {}) {
+        return this.dockerJson(remoteId, 'POST', `/api/host/docker/containers/${enc(id)}/stop?${new URLSearchParams({ projectId })}`, undefined, options);
+    }
+    async dockerLoadImage(remoteId, body, options = {}) {
+        const path = '/api/host/docker/images/load';
+        const answer = await this.dockerUpload(remoteId, path, 'POST', body, options);
+        return parseDockerAnswer(host_docker_dto_1.DockerImageLoadResultSchema, answer, remoteId, path);
+    }
+    async dockerWriteArchive(remoteId, input, body, options = {}) {
+        const answer = await this.dockerUpload(remoteId, `/api/host/docker/archive?${new URLSearchParams(input)}`, 'PUT', body, options);
+        return parseDockerAnswer(host_docker_dto_1.DockerArchiveWriteResultSchema, answer, remoteId, '/api/host/docker/archive');
+    }
+    async dockerPrepareBinds(remoteId, input, options = {}) {
+        await this.dockerJson(remoteId, 'POST', '/api/host/docker/binds', input, options);
+    }
+    dockerStopProject(remoteId, projectId, options = {}) {
+        return this.dockerJson(remoteId, 'POST', `/api/host/docker/projects/${enc(projectId)}/stop`, undefined, options);
+    }
+    async dockerProbe(remoteId, body, options = {}) {
+        await this.dockerUpload(remoteId, '/api/host/docker/probe', 'POST', body, options);
+    }
+    dockerUpload(remoteId, path, method, body, options = {}) {
+        return this.dockerCall(remoteId, options, async (client) => {
+            try {
+                const response = await client.stream(method, path, {
+                    body,
+                    signal: options.signal,
+                    headers: { 'Content-Type': 'application/x-tar' },
+                });
+                let text = '';
+                for await (const chunk of response) {
+                    if (text.length < 64 * 1024)
+                        text += chunk.toString('utf8');
+                }
+                return text;
+            }
+            finally {
+                body.destroy();
+            }
+        });
+    }
+    dockerVersion(remoteId, options = {}) {
+        return this.dockerJson(remoteId, 'GET', '/api/host/docker/version', undefined, options);
+    }
+    async listTranscripts(remoteId, refs) {
+        const response = await this.request(remoteId, '/api/host/transcripts/list', {
+            method: 'POST',
+            body: JSON.stringify({ refs }),
+            expect: [200],
+        });
+        return parseBody(transcript_transfer_dto_1.TranscriptListingSchema, response, remoteId, '/api/host/transcripts/list');
+    }
+    async uploadTranscript(remoteId, file, files, signal) {
+        await this.transferTranscript(remoteId, file, signal, async (send, transferSignal) => {
+            const { stream, size } = await files.read(file);
+            try {
+                (0, transcript_files_service_1.assertTranscriptSize)(size);
+                const init = {
+                    method: 'PUT',
+                    body: stream,
+                    duplex: 'half',
+                    signal: transferSignal,
+                    headers: {
+                        ...(await this.apiKeys.headers(remoteId)),
+                        'content-type': 'application/octet-stream',
+                        'content-length': String(size),
+                    },
+                };
+                const response = await send(init);
+                try {
+                    if (response.status !== 204)
+                        throw new Error(`Transcript upload answered ${response.status}`);
+                }
+                finally {
+                    await discardBody(response);
+                }
+            }
+            finally {
+                stream.destroy();
+            }
+        });
+    }
+    async downloadTranscript(remoteId, file, files, signal) {
+        await this.transferTranscript(remoteId, file, signal, async (send, transferSignal) => {
+            const response = await send({
+                signal: transferSignal,
+                headers: await this.apiKeys.headers(remoteId),
+            });
+            try {
+                if (response.status !== 200)
+                    throw new Error(`Transcript download answered ${response.status}`);
+                const length = response.headers.get('content-length');
+                if (length === null || !/^\d+$/.test(length) || !response.body)
+                    throw new Error('Transcript response requires Content-Length and a body');
+                const size = Number(length);
+                (0, transcript_files_service_1.assertTranscriptSize)(size);
+                const stream = node_stream_1.Readable.fromWeb(response.body);
+                try {
+                    await files.write(file, stream, size, transferSignal);
+                }
+                finally {
+                    stream.destroy();
+                }
+            }
+            finally {
+                await discardBody(response);
+            }
+        });
+    }
+    async transferTranscript(remoteId, file, signal, transfer) {
+        const { baseUrl, certificate } = (0, remote_tls_1.requireRemoteTls)(await this.storage.getRemote(remoteId));
+        const path = `/api/host/transcripts?${new URLSearchParams(file).toString()}`;
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        const timer = setTimeout(abort, transcript_transfer_dto_1.TRANSCRIPT_TIMEOUT_MS);
+        timer.unref?.();
+        try {
+            controller.signal.throwIfAborted();
+            const url = `${baseUrl.replace(/\/+$/, '')}${path}`;
+            await transfer((init) => (0, remote_tls_1.remoteFetch)(url, init, certificate), controller.signal);
+        }
+        catch (error) {
+            throw new RemoteHostRequestError(`Transcript transfer failed: ${error instanceof Error ? error.message : String(error)}`, { remoteId, path, status: null, hostCode: null });
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+        }
+    }
+    async projectExists(remoteId, projectId) {
+        const response = await this.request(remoteId, `/api/projects/${enc(projectId)}`, {
+            method: 'GET',
+            expect: [200, 404],
+        });
+        await discardBody(response);
+        return response.status === 200;
+    }
+    async importProject(remoteId, replica) {
+        const response = await this.request(remoteId, '/api/host/projects/import', {
+            method: 'POST',
+            body: JSON.stringify(replica),
+            contentType: shared_2.PROJECT_REPLICA_CONTENT_TYPE,
+            timeoutMs: REPLICA_TIMEOUT_MS,
+            expect: [201, 409],
+        });
+        if (response.status === 409) {
+            const code = await readErrorCode(response);
+            if (code !== 'PROJECT_EXISTS') {
+                throw new RemoteHostRequestError('Host refused the project import.', {
+                    remoteId,
+                    path: '/api/host/projects/import',
+                    status: 409,
+                    hostCode: code,
+                });
+            }
+            return { imported: false, reason: 'PROJECT_EXISTS' };
+        }
+        const result = shared_2.ProjectReplicaImportResultSchema.parse(await response.json());
+        return { imported: true, cursor: result.cursor };
+    }
+    async exportReplica(remoteId, projectId, scope) {
+        const path = `/api/host/projects/${enc(projectId)}/replica?scope=${scope}`;
+        const response = await this.request(remoteId, path, {
+            method: 'GET',
+            timeoutMs: REPLICA_TIMEOUT_MS,
+            expect: [200],
+        });
+        const replica = shared_2.ProjectReplicaV1Schema.parse(await response.json());
+        if (replica.scope !== scope) {
+            throw new RemoteHostRequestError('Host returned a replica of the wrong scope.', {
+                remoteId,
+                path,
+                status: response.status,
+                hostCode: null,
+            });
+        }
+        return replica;
+    }
+    async changes(remoteId, projectId, options) {
+        const query = new URLSearchParams();
+        if (options.since)
+            query.set('since', options.since);
+        if (options.full)
+            query.set('full', 'true');
+        const queryString = query.toString();
+        const suffix = queryString ? `?${queryString}` : '';
+        const response = await this.request(remoteId, `/api/host/projects/${enc(projectId)}/changes${suffix}`, { method: 'GET', timeoutMs: REPLICA_TIMEOUT_MS, expect: [200] });
+        return shared_2.ProjectReplicaChangesSchema.parse(await response.json());
+    }
+    async freeze(remoteId, projectId) {
+        const path = `/api/host/projects/${enc(projectId)}/freeze`;
+        const response = await this.request(remoteId, path, {
+            method: 'POST',
+            expect: [200],
+        });
+        const body = await response.json().catch(() => null);
+        const parsed = FrozenProjectSchema.safeParse(body);
+        if (!parsed.success) {
+            throw new RemoteHostRequestError('Host returned an invalid freeze answer.', {
+                remoteId,
+                path,
+                status: response.status,
+                hostCode: null,
+            });
+        }
+        return parsed.data;
+    }
+    async thaw(remoteId, projectId) {
+        const response = await this.request(remoteId, `/api/host/projects/${enc(projectId)}/thaw`, {
+            method: 'POST',
+            expect: [204],
+        });
+        await discardBody(response);
+    }
+    async stopSessions(remoteId, projectId) {
+        const response = await this.request(remoteId, `/api/host/projects/${enc(projectId)}/stop-sessions`, { method: 'POST', expect: [204] });
+        await discardBody(response);
+    }
+    async settleTime(remoteId, projectId) {
+        const response = await this.request(remoteId, `/api/host/projects/${enc(projectId)}/settle-time`, {
+            method: 'POST',
+            timeoutMs: (0, env_config_1.getEnvConfig)().REMOTES_TIME_SETTLE_TIMEOUT_MS + CONTROL_TIMEOUT_MS,
+            expect: [200],
+        });
+        return project_time_settler_service_1.ProjectTimeSettlementSchema.parse(await response.json());
+    }
+    async release(remoteId, projectId) {
+        const response = await this.request(remoteId, `/api/host/projects/${enc(projectId)}/release`, {
+            method: 'POST',
+            expect: [204, 404],
+        });
+        await discardBody(response);
+    }
+    async findEpicByIdempotencyKey(remoteId, projectId, key) {
+        const path = `/api/host/projects/${enc(projectId)}/epics/by-idempotency-key/${enc(key)}`;
+        const response = await this.request(remoteId, path, { method: 'GET', expect: [200, 404] });
+        if (response.status === 404) {
+            await discardBody(response);
+            return null;
+        }
+        return (await parseBody(EpicIdSchema, response, remoteId, path)).epicId;
+    }
+    async createEpic(remoteId, epic) {
+        const path = '/api/epics';
+        const response = await this.request(remoteId, path, {
+            method: 'POST',
+            body: JSON.stringify(epic),
+            expect: [201, 423],
+        });
+        if (response.status === 423) {
+            const hostCode = await readErrorCode(response);
+            throw new error_types_1.ConflictError('The remote project is locked for a handoff; try again shortly.', {
+                code: 'REMOTE_PROJECT_LOCKED',
+                retryable: true,
+                remoteId,
+                projectId: epic.projectId,
+                hostCode,
+            });
+        }
+        return { id: (await parseBody(CreatedEpicSchema, response, remoteId, path)).id };
+    }
+    async syncDevice(remoteId) {
+        const remote = await this.storage.getRemote(remoteId);
+        const path = '/api/host/sync/device';
+        const response = await this.request(remoteId, path, { method: 'GET', expect: [200] });
+        const device = await parseBody(file_sync_dto_1.SyncDeviceSchema, response, remoteId, path);
+        return {
+            deviceId: device.deviceId,
+            address: dialAddress(device.address, (0, remote_address_1.requireRemoteAddress)(remote)),
+        };
+    }
+    async syncPeer(remoteId, peer) {
+        const response = await this.request(remoteId, '/api/host/sync/peer', {
+            method: 'POST',
+            body: JSON.stringify(peer),
+            expect: [204],
+        });
+        await discardBody(response);
+    }
+    async syncFolders(remoteId, folder) {
+        const path = '/api/host/sync/folders';
+        const response = await this.request(remoteId, path, {
+            method: 'POST',
+            body: JSON.stringify(folder),
+            expect: [200],
+        });
+        return parseBody(file_sync_dto_1.SyncFolderSchema, response, remoteId, path);
+    }
+    async syncFolderType(remoteId, folderId, patch) {
+        const response = await this.request(remoteId, `/api/host/sync/folders/${enc(folderId)}`, {
+            method: 'PATCH',
+            body: JSON.stringify(patch),
+            expect: [204],
+        });
+        await discardBody(response);
+    }
+    async syncRemoveFolder(remoteId, folderId) {
+        const response = await this.request(remoteId, `/api/host/sync/folders/${enc(folderId)}`, {
+            method: 'DELETE',
+            expect: [204],
+        });
+        await discardBody(response);
+    }
+    async syncScan(remoteId, folderId) {
+        const response = await this.request(remoteId, `/api/host/sync/folders/${enc(folderId)}/scan`, {
+            method: 'POST',
+            expect: [204],
+            timeoutMs: file_sync_service_1.SCAN_TIMEOUT_MS + CONTROL_TIMEOUT_MS,
+        });
+        await discardBody(response);
+    }
+    async syncRevert(remoteId, folderId) {
+        const response = await this.request(remoteId, `/api/host/sync/folders/${enc(folderId)}/revert`, { method: 'POST', expect: [204] });
+        await discardBody(response);
+    }
+    async syncStatus(remoteId, folderId, deviceId) {
+        const query = new URLSearchParams({ folder: folderId });
+        if (deviceId)
+            query.set('device', deviceId);
+        const path = `/api/host/sync/status?${query.toString()}`;
+        const response = await this.request(remoteId, path, { method: 'GET', expect: [200] });
+        return parseBody(file_sync_dto_1.FolderSyncStatusSchema, response, remoteId, path);
+    }
+    async setInstanceLabel(remoteId, label) {
+        const response = await this.request(remoteId, '/api/cloud/instance-label', {
+            method: 'PUT',
+            body: JSON.stringify({ label }),
+            expect: [200],
+        });
+        await discardBody(response);
+    }
+    async remoteRuntime(remoteId) {
+        const { baseUrl, certificate } = (0, remote_tls_1.requireRemoteTls)(await this.storage.getRemote(remoteId));
+        return this.runtimeAt(baseUrl, certificate);
+    }
+    async certificateOf(remoteId) {
+        return (0, remote_tls_1.requireRemoteCertificate)(await this.storage.getRemote(remoteId));
+    }
+    async runtimeAt(baseUrl, certificate) {
+        const response = await this.fetchUrl(baseUrl, '/api/runtime', {
+            method: 'GET',
+            expect: [200],
+            timeoutMs: RUNTIME_TIMEOUT_MS,
+            label: baseUrl,
+            certificate,
+        });
+        return parseBody(HostRuntimeSchema, response, baseUrl, '/api/runtime');
+    }
+    async discoverRuntime(origin) {
+        const answer = await (0, remote_discovery_1.discoverRuntime)(origin, RUNTIME_TIMEOUT_MS);
+        const parsed = HostRuntimeSchema.safeParse(answer.body);
+        return {
+            runtime: answer.status === 200 && parsed.success ? parsed.data : null,
+            certificate: answer.certificate,
+        };
+    }
+    async claim(bootstrapUrl, certificate, body, apiKey) {
+        const response = await this.fetchUrl(bootstrapUrl, '/api/host/claim', {
+            apiKey,
+            certificate,
+            method: 'POST',
+            body: JSON.stringify(body),
+            timeoutMs: CLAIM_TIMEOUT_MS,
+            expect: [200, 409, 504],
+            label: bootstrapUrl,
+        });
+        if (response.status === 200) {
+            await discardBody(response);
+            return 'claimed';
+        }
+        const code = await readErrorCode(response);
+        if (response.status === 504)
+            return 'starting';
+        if (code === 'ALREADY_CLAIMED')
+            return 'already_claimed';
+        throw new RemoteHostRequestError(`The VM refused the claim${code ? ` (${code})` : ''}.`, {
+            remoteId: bootstrapUrl,
+            path: '/api/host/claim',
+            status: response.status,
+            hostCode: code,
+        });
+    }
+    async verifyProviderAuth(remoteId, provider, opencodeProviderIds) {
+        const path = '/api/host/provider-auth/verify';
+        const response = await this.request(remoteId, path, {
+            method: 'POST',
+            body: JSON.stringify({ provider, opencodeProviderIds }),
+            timeoutMs: VERIFY_TIMEOUT_MS,
+            expect: [200],
+        });
+        return parseBody(HostProviderVerifySchema, response, remoteId, path);
+    }
+    async applyProviderAuth(remoteId, bundle) {
+        const response = await this.request(remoteId, '/api/host/provider-auth', {
+            method: 'POST',
+            body: JSON.stringify(bundle),
+            expect: [200],
+        });
+        await discardBody(response);
+    }
+    async applySshKeys(remoteId, keys) {
+        const response = await this.request(remoteId, '/api/host/ssh-keys', {
+            method: 'POST',
+            body: JSON.stringify({ keys }),
+            expect: [200],
+        });
+        await discardBody(response);
+    }
+    async requestHostUpdate(remoteId, version) {
+        const response = await this.request(remoteId, '/api/host/update', {
+            method: 'POST',
+            body: JSON.stringify({ version }),
+            expect: [202, 409],
+        });
+        if (response.status === 202) {
+            await discardBody(response);
+            return 'started';
+        }
+        const code = await readErrorCode(response);
+        if (code === 'UPDATE_IN_PROGRESS')
+            return 'in_progress';
+        throw new RemoteHostRequestError(`The host refused the update${code ? ` (${code})` : ''}.`, {
+            remoteId,
+            path: '/api/host/update',
+            status: 409,
+            hostCode: code,
+        });
+    }
+    async hostUpdateStatus(remoteId) {
+        const path = '/api/host/update';
+        const response = await this.request(remoteId, path, { method: 'GET', expect: [200] });
+        return (await parseBody(HostUpdateStatusBodySchema, response, remoteId, path)).status;
+    }
+    async requestDocker(remoteId) {
+        const response = await this.request(remoteId, '/api/host/docker', {
+            method: 'POST',
+            body: '{}',
+            expect: [202],
+        });
+        return parseBody(zod_1.z.object({ jobId: zod_1.z.string().nullable() }), response, remoteId, '/api/host/docker');
+    }
+    async dockerStatus(remoteId) {
+        const path = '/api/host/docker';
+        const response = await this.request(remoteId, path, { method: 'GET', expect: [200] });
+        return (await parseBody(zod_1.z.object({ status: host_helper_service_1.HostDockerStatusSchema.nullable() }), response, remoteId, path)).status;
+    }
+    getProviderCliSettingsStatus(remoteId) {
+        return this.hostSettingsRequest(remoteId, '/api/host/provider-clis/status', 'GET', undefined, 200, shared_1.HostProviderCliSettingsStatusSchema, 3000);
+    }
+    async putProviderCliSettings(remoteId, body) {
+        await this.hostSettingsRequest(remoteId, '/api/host/provider-clis', 'PUT', JSON.stringify(body), 202, zod_1.z.object({ revision: zod_1.z.literal(body.revision) }), 3000);
+    }
+    async checkProviderClis(remoteId) {
+        await this.hostSettingsRequest(remoteId, '/api/host/provider-clis/check', 'POST', undefined, 202, zod_1.z.object({ accepted: zod_1.z.literal(true) }), 3000);
+    }
+    getSkillSettingsStatus(remoteId) {
+        return this.hostSettingsRequest(remoteId, '/api/host/skill-settings/status', 'GET', undefined, 200, shared_2.HostSkillSettingsStatusSchema, 3000);
+    }
+    async putSkillSettings(remoteId, body) {
+        await this.hostSettingsRequest(remoteId, '/api/host/skill-settings', 'PUT', JSON.stringify(body), 202, zod_1.z.object({ revision: zod_1.z.literal(body.revision) }), 3000);
+    }
+    async uploadSkillSourceContent(remoteId, name, contentHash, stream, signal) {
+        const path = `/api/host/skill-settings/local-sources/${enc(name)}/content?${new URLSearchParams({ contentHash })}`;
+        try {
+            await this.hostSettingsRequest(remoteId, path, 'PUT', stream, 200, zod_1.z.object({ name: zod_1.z.literal(name), contentHash: zod_1.z.literal(contentHash) }), 60_000, signal);
+        }
+        finally {
+            stream.destroy();
+        }
+    }
+    async hostSettingsRequest(remoteId, path, method, body, expectedStatus, schema, timeoutMs, signal) {
+        const { baseUrl, certificate } = (0, remote_tls_1.requireRemoteTls)(await this.storage.getRemote(remoteId));
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted)
+            controller.abort();
+        const timeout = setTimeout(abort, timeoutMs);
+        timeout.unref?.();
+        let response;
+        try {
+            const init = {
+                method,
+                signal: controller.signal,
+                ...(body === undefined
+                    ? {}
+                    : {
+                        body: body,
+                        headers: {
+                            'content-type': typeof body === 'string' ? 'application/json' : 'application/x-tar',
+                        },
+                        ...(typeof body === 'string' ? {} : { duplex: 'half' }),
+                    }),
+            };
+            init.headers = { ...(await this.apiKeys.headers(remoteId)), ...init.headers };
+            response = await (0, remote_tls_1.remoteFetch)(`${baseUrl.replace(/\/+$/, '')}${path}`, init, certificate);
+            if (response.status !== expectedStatus)
+                throw new RemoteHostRequestError('Host settings request failed', {
+                    remoteId,
+                    path,
+                    status: response.status,
+                    hostCode: null,
+                });
+            return await parseBody(schema, response, remoteId, path);
+        }
+        finally {
+            if (response)
+                await discardBody(response);
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', abort);
+        }
+    }
+    async request(remoteId, path, options) {
+        const remote = await this.storage.getRemote(remoteId);
+        const { baseUrl, certificate } = (0, remote_tls_1.requireRemoteTls)(remote);
+        return this.fetchUrl(baseUrl, path, {
+            ...options,
+            apiKey: await this.apiKeys.get(remoteId),
+            label: `Remote "${remote.name}"`,
+            remoteId,
+            certificate,
+        });
+    }
+    async fetchUrl(baseUrl, path, options) {
+        const remoteId = options.remoteId ?? baseUrl;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? CONTROL_TIMEOUT_MS);
+        timeout.unref?.();
+        let response;
+        try {
+            response = await (0, remote_tls_1.remoteFetch)(`${baseUrl.replace(/\/+$/, '')}${path}`, {
+                method: options.method,
+                headers: {
+                    ...(0, remote_api_key_service_1.remoteAuthorization)(options.apiKey),
+                    ...(options.body !== undefined
+                        ? { 'content-type': options.contentType ?? 'application/json' }
+                        : {}),
+                },
+                signal: controller.signal,
+                ...(options.body !== undefined && {
+                    body: options.body,
+                }),
+            }, options.certificate);
+        }
+        catch (error) {
+            throw new RemoteHostRequestError(`${options.label} is unreachable: ${error instanceof Error ? error.message : String(error)}`, { remoteId, path, status: null, hostCode: null });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        if (!options.expect.includes(response.status)) {
+            const hostCode = await readErrorCode(response);
+            if (path === '/api/host/docker' && hostCode === 'HOST_HELPER_OUTDATED') {
+                throw new RemoteHostRequestError(`The host helper needs one manual migration: ${host_helper_service_1.HOST_HELPER_MIGRATION}`, { remoteId, path, status: response.status, hostCode: 'HOST_HELPER_OUTDATED' });
+            }
+            throw new RemoteHostRequestError(`${options.label} answered ${response.status} to ${options.method} ${path.split('?')[0]}${hostCode ? ` (${hostCode})` : ''}.`, { remoteId, path, status: response.status, hostCode });
+        }
+        return response;
+    }
+};
+exports.RemoteHostClient = RemoteHostClient;
+exports.RemoteHostClient = RemoteHostClient = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
+    __metadata("design:paramtypes", [Object, remote_api_key_service_1.RemoteApiKeyService])
+], RemoteHostClient);
+async function discardBody(response) {
+    await response.body?.cancel().catch(() => undefined);
+}
+function parseDockerAnswer(schema, answer, remoteId, path) {
+    let value = null;
+    try {
+        value = JSON.parse(answer);
+    }
+    catch {
+    }
+    const parsed = schema.safeParse(value);
+    if (!parsed.success)
+        throw new RemoteHostRequestError('Docker host request failed', {
+            remoteId,
+            path,
+            status: null,
+            hostCode: 'invalid-response',
+        });
+    return parsed.data;
+}
+async function parseBody(schema, response, remoteId, path) {
+    const parsed = schema.safeParse(await response.json().catch(() => null));
+    if (!parsed.success) {
+        throw new RemoteHostRequestError(`Host returned an invalid answer to ${path.split('?')[0]}.`, {
+            remoteId,
+            path,
+            status: response.status,
+            hostCode: null,
+        });
+    }
+    return parsed.data;
+}
+function dialAddress(address, baseUrl) {
+    const match = /^(tcp|quic):\/\/.*:(\d+)$/.exec(address);
+    if (!match)
+        return address;
+    return `${match[1]}://${new URL(baseUrl).hostname}:${match[2]}`;
+}
+function enc(value) {
+    return encodeURIComponent(value);
+}
+async function readErrorCode(response) {
+    try {
+        const body = (await response.json());
+        const detailCode = body.details?.code;
+        if (typeof detailCode === 'string')
+            return detailCode;
+        return typeof body.code === 'string' ? body.code : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=remote-host.client.js.map