devchain-cli 0.24.1 → 0.25.0

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

@@ -14,80 +14,47 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 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 common_1 = require("@nestjs/common");
 const node_stream_1 = require("node:stream");
+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 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_api_key_service_1 = require("../auth/remote-api-key.service");
 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;
+const host_routes_1 = require("../contract/host-routes");
+const host_transport_1 = require("../transport/host-transport");
+var host_transport_2 = require("../transport/host-transport");
+Object.defineProperty(exports, "RemoteHostRequestError", { enumerable: true, get: function () { return host_transport_2.RemoteHostRequestError; } });
 let RemoteHostClient = class RemoteHostClient {
     storage;
     apiKeys;
-    constructor(storage, apiKeys) {
+    runtimeTimeoutMs;
+    constructor(storage, apiKeys, runtimeTimeoutMs = host_routes_1.RUNTIME_TIMEOUT_MS) {
         this.storage = storage;
         this.apiKeys = apiKeys;
+        this.runtimeTimeoutMs = runtimeTimeoutMs;
     }
-    async dockerClient(remoteId, options) {
+    async target(remoteId) {
         const remote = await this.storage.getRemote(remoteId);
-        const { baseUrl, certificate } = (0, remote_tls_1.requireRemoteTls)(remote);
+        return {
+            ...(0, remote_tls_1.requireRemoteTls)(remote),
+            apiKey: await this.apiKeys.get(remoteId),
+            label: `Remote "${remote.name}"`,
+            remoteId,
+        };
+    }
+    async call(remoteId, route, params, options) {
+        return (0, host_transport_1.send)(await this.target(remoteId), route, params, options);
+    }
+    async dockerClient(remoteId, options) {
+        const { baseUrl, certificate, apiKey } = await this.target(remoteId);
         return docker_engine_client_1.DockerEngineClient.forHttp(baseUrl, (0, remote_tls_1.pinnedTlsOptions)(certificate), {
-            ...(await this.apiKeys.headers(remoteId)),
+            ...(0, remote_api_key_service_1.remoteAuthorization)(apiKey),
             ...(options.apiVersion ? { [host_docker_dto_1.DOCKER_API_VERSION_HEADER]: options.apiVersion } : {}),
         });
     }
@@ -96,10 +63,12 @@ let RemoteHostClient = class RemoteHostClient {
             return await action(await this.dockerClient(remoteId, options));
         }
         catch (error) {
-            throw new RemoteHostRequestError('Docker host request failed', {
+            const status = error instanceof docker_engine_client_1.DockerEngineError ? (error.status ?? null) : null;
+            const reason = error instanceof docker_engine_client_1.DockerEngineError ? error.reason : undefined;
+            throw new host_transport_1.RemoteHostRequestError(`Docker host request failed${status ? ` (HTTP ${status})` : ''}${reason ? `: ${reason}` : ''}`, {
                 remoteId,
                 path: '/api/host/docker',
-                status: error instanceof docker_engine_client_1.DockerEngineError ? (error.status ?? null) : null,
+                status,
                 hostCode: error instanceof docker_engine_client_1.DockerEngineError ? error.code : null,
             });
         }
@@ -107,8 +76,8 @@ let RemoteHostClient = class RemoteHostClient {
     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);
+    dockerScan(remoteId, paths, options = {}, volumes, networks) {
+        return this.dockerJson(remoteId, 'POST', '/api/host/docker/scan', { paths, ...(volumes && { volumes }), ...(networks && { networks }) }, options);
     }
     dockerCapacity(remoteId, paths, options = {}) {
         return this.dockerJson(remoteId, 'POST', '/api/host/docker/capacity', { paths }, options);
@@ -116,6 +85,11 @@ let RemoteHostClient = class RemoteHostClient {
     dockerImagesPresent(remoteId, ids, options = {}) {
         return this.dockerJson(remoteId, 'POST', '/api/host/docker/images/present', { ids }, options);
     }
+    async dockerMatchImages(remoteId, refs, options = {}) {
+        const path = '/api/host/docker/images/match';
+        const answer = await this.dockerJson(remoteId, 'POST', path, { refs }, options);
+        return checkDockerAnswer(host_docker_dto_1.DockerImageMatchResultSchema, answer, remoteId, path);
+    }
     dockerCreateVolume(remoteId, input, options = {}) {
         return this.dockerJson(remoteId, 'POST', '/api/host/docker/volumes', input, options);
     }
@@ -129,7 +103,7 @@ let RemoteHostClient = class RemoteHostClient {
         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);
+        return this.dockerJson(remoteId, 'DELETE', `/api/host/docker/${kind}/${enc(id)}?${new URLSearchParams({ projectId, ...(options.projectRoot !== undefined ? { projectRoot: options.projectRoot } : {}) })}`, undefined, options);
     }
     dockerSaveImage(remoteId, id, options = {}) {
         return this.dockerCall(remoteId, options, (client) => client.stream('GET', `/api/host/docker/images/${enc(id)}/archive`, {
@@ -148,7 +122,7 @@ let RemoteHostClient = class RemoteHostClient {
         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);
+        return this.dockerJson(remoteId, 'POST', `/api/host/docker/containers/${enc(id)}/stop?${new URLSearchParams({ projectId, ...(options.projectRoot !== undefined ? { projectRoot: options.projectRoot } : {}) })}`, undefined, options);
     }
     async dockerLoadImage(remoteId, body, options = {}) {
         const path = '/api/host/docker/images/load';
@@ -192,15 +166,10 @@ let RemoteHostClient = class RemoteHostClient {
         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');
+        return (await this.call(remoteId, host_routes_1.hostRoutes.listTranscripts, {}, { body: { refs } })).body;
     }
     async uploadTranscript(remoteId, file, files, signal) {
-        await this.transferTranscript(remoteId, file, signal, async (send, transferSignal) => {
+        await this.transferTranscript(remoteId, file, signal, async (fetchTranscript, transferSignal) => {
             const { stream, size } = await files.read(file);
             try {
                 (0, transcript_files_service_1.assertTranscriptSize)(size);
@@ -210,18 +179,17 @@ let RemoteHostClient = class RemoteHostClient {
                     duplex: 'half',
                     signal: transferSignal,
                     headers: {
-                        ...(await this.apiKeys.headers(remoteId)),
                         'content-type': 'application/octet-stream',
                         'content-length': String(size),
                     },
                 };
-                const response = await send(init);
+                const response = await fetchTranscript(init);
                 try {
                     if (response.status !== 204)
                         throw new Error(`Transcript upload answered ${response.status}`);
                 }
                 finally {
-                    await discardBody(response);
+                    await (0, host_transport_1.discardBody)(response);
                 }
             }
             finally {
@@ -230,10 +198,9 @@ let RemoteHostClient = class RemoteHostClient {
         });
     }
     async downloadTranscript(remoteId, file, files, signal) {
-        await this.transferTranscript(remoteId, file, signal, async (send, transferSignal) => {
-            const response = await send({
+        await this.transferTranscript(remoteId, file, signal, async (fetchTranscript, transferSignal) => {
+            const response = await fetchTranscript({
                 signal: transferSignal,
-                headers: await this.apiKeys.headers(remoteId),
             });
             try {
                 if (response.status !== 200)
@@ -252,12 +219,12 @@ let RemoteHostClient = class RemoteHostClient {
                 }
             }
             finally {
-                await discardBody(response);
+                await (0, host_transport_1.discardBody)(response);
             }
         });
     }
     async transferTranscript(remoteId, file, signal, transfer) {
-        const { baseUrl, certificate } = (0, remote_tls_1.requireRemoteTls)(await this.storage.getRemote(remoteId));
+        const { baseUrl, certificate, apiKey } = await this.target(remoteId);
         const path = `/api/host/transcripts?${new URLSearchParams(file).toString()}`;
         const controller = new AbortController();
         const abort = () => controller.abort();
@@ -269,10 +236,16 @@ let RemoteHostClient = class RemoteHostClient {
         try {
             controller.signal.throwIfAborted();
             const url = `${baseUrl.replace(/\/+$/, '')}${path}`;
-            await transfer((init) => (0, remote_tls_1.remoteFetch)(url, init, certificate), controller.signal);
+            await transfer((init) => (0, remote_tls_1.remoteFetch)(url, {
+                ...init,
+                headers: {
+                    ...(0, remote_api_key_service_1.remoteAuthorization)(apiKey),
+                    ...init.headers,
+                },
+            }, certificate), controller.signal);
         }
         catch (error) {
-            throw new RemoteHostRequestError(`Transcript transfer failed: ${error instanceof Error ? error.message : String(error)}`, { remoteId, path, status: null, hostCode: null });
+            throw new host_transport_1.RemoteHostRequestError(`Transcript transfer failed: ${error instanceof Error ? error.message : String(error)}`, { remoteId, path, status: null, hostCode: null });
         }
         finally {
             clearTimeout(timer);
@@ -280,48 +253,33 @@ let RemoteHostClient = class RemoteHostClient {
         }
     }
     async projectExists(remoteId, projectId) {
-        const response = await this.request(remoteId, `/api/projects/${enc(projectId)}`, {
-            method: 'GET',
-            expect: [200, 404],
-        });
-        await discardBody(response);
+        const response = await this.call(remoteId, host_routes_1.hostRoutes.projectExists, { projectId });
         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],
-        });
+        const response = await this.call(remoteId, host_routes_1.hostRoutes.importProject, {}, { body: replica });
         if (response.status === 409) {
-            const code = await readErrorCode(response);
+            const code = response.body;
             if (code !== 'PROJECT_EXISTS') {
-                throw new RemoteHostRequestError('Host refused the project import.', {
+                throw new host_transport_1.RemoteHostRequestError('Host refused the project import.', {
                     remoteId,
-                    path: '/api/host/projects/import',
+                    path: host_routes_1.hostRoutes.importProject.path({}),
                     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 };
+        return { imported: true, cursor: response.body.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());
+        const params = { projectId, scope };
+        const response = await this.call(remoteId, host_routes_1.hostRoutes.exportReplica, params);
+        const replica = response.body;
         if (replica.scope !== scope) {
-            throw new RemoteHostRequestError('Host returned a replica of the wrong scope.', {
+            throw new host_transport_1.RemoteHostRequestError('Host returned a replica of the wrong scope.', {
                 remoteId,
-                path,
+                path: host_routes_1.hostRoutes.exportReplica.path(params),
                 status: response.status,
                 hostCode: null,
             });
@@ -329,157 +287,120 @@ let RemoteHostClient = class RemoteHostClient {
         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());
+        return (await this.call(remoteId, host_routes_1.hostRoutes.changes, { projectId, ...options })).body;
     }
     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;
+        return (await this.call(remoteId, host_routes_1.hostRoutes.freeze, { projectId })).body;
+    }
+    async installGitGuard(remoteId, projectId, request) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.installGitGuard, { projectId }, { body: request }))
+            .body;
+    }
+    async removeGitGuard(remoteId, projectId, options = {}) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.removeGitGuard, { projectId }, {
+            ...(options.refreshIndex !== undefined && {
+                body: { refreshIndex: options.refreshIndex },
+            }),
+            ...(options.refreshIndex && { timeoutMs: host_routes_1.REPLICA_TIMEOUT_MS }),
+        })).body;
+    }
+    async refreshGitIndex(remoteId, projectId, since) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.refreshGitIndex, { projectId }, { body: { since } })).body;
     }
     async thaw(remoteId, projectId) {
-        const response = await this.request(remoteId, `/api/host/projects/${enc(projectId)}/thaw`, {
-            method: 'POST',
-            expect: [204],
-        });
-        await discardBody(response);
+        await this.call(remoteId, host_routes_1.hostRoutes.thaw, { projectId });
+    }
+    async listSessions(remoteId, projectId, options = {}) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.listSessions, { projectId }, options)).body;
     }
     async stopSessions(remoteId, projectId) {
-        const response = await this.request(remoteId, `/api/host/projects/${enc(projectId)}/stop-sessions`, { method: 'POST', expect: [204] });
-        await discardBody(response);
+        await this.call(remoteId, host_routes_1.hostRoutes.stopSessions, { projectId });
     }
     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());
+        return (await this.call(remoteId, host_routes_1.hostRoutes.settleTime, { projectId }, {
+            timeoutMs: (0, env_config_1.getEnvConfig)().REMOTES_TIME_SETTLE_TIMEOUT_MS + host_routes_1.CONTROL_TIMEOUT_MS,
+        })).body;
     }
     async release(remoteId, projectId) {
-        const response = await this.request(remoteId, `/api/host/projects/${enc(projectId)}/release`, {
-            method: 'POST',
-            expect: [204, 404],
-        });
-        await discardBody(response);
+        await this.call(remoteId, host_routes_1.hostRoutes.release, { projectId });
     }
     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;
+        const response = await this.call(remoteId, host_routes_1.hostRoutes.findEpicByIdempotencyKey, {
+            projectId,
+            key,
+        });
+        return response.status === 404 ? null : response.body.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],
-        });
+        const response = await this.call(remoteId, host_routes_1.hostRoutes.createEpic, {}, { body: epic });
         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,
+                hostCode: response.body,
             });
         }
-        return { id: (await parseBody(CreatedEpicSchema, response, remoteId, path)).id };
+        return { id: response.body.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)),
-        };
+        const target = await this.target(remoteId);
+        const device = (await (0, host_transport_1.send)(target, host_routes_1.hostRoutes.syncDevice, {})).body;
+        return { deviceId: device.deviceId, address: dialAddress(device.address, target.baseUrl) };
     }
     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);
+        await this.call(remoteId, host_routes_1.hostRoutes.syncPeer, {}, { body: peer });
     }
     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);
+        return (await this.call(remoteId, host_routes_1.hostRoutes.syncFolders, {}, { body: folder })).body;
+    }
+    async syncForceCopyBackup(remoteId, request) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.syncForceCopyBackup, {}, { body: request })).body;
     }
     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);
+        await this.call(remoteId, host_routes_1.hostRoutes.syncFolderType, { folderId }, { body: patch });
+    }
+    async syncFolderConfiguration(remoteId, folderId) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.syncFolderConfiguration, { folderId })).body;
+    }
+    async syncFolderIgnores(remoteId, folderId) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.syncFolderIgnores, { folderId })).body;
     }
     async syncRemoveFolder(remoteId, folderId) {
-        const response = await this.request(remoteId, `/api/host/sync/folders/${enc(folderId)}`, {
-            method: 'DELETE',
-            expect: [204],
-        });
-        await discardBody(response);
+        await this.call(remoteId, host_routes_1.hostRoutes.syncRemoveFolder, { folderId });
     }
     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);
+        await this.call(remoteId, host_routes_1.hostRoutes.syncScan, { folderId });
     }
     async syncRevert(remoteId, folderId) {
-        const response = await this.request(remoteId, `/api/host/sync/folders/${enc(folderId)}/revert`, { method: 'POST', expect: [204] });
-        await discardBody(response);
+        await this.call(remoteId, host_routes_1.hostRoutes.syncRevert, { folderId });
+    }
+    async syncOverride(remoteId, folderId) {
+        await this.call(remoteId, host_routes_1.hostRoutes.syncOverride, { folderId });
     }
-    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 syncLocalChanges(remoteId, folderId) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.syncLocalChanges, { folderId })).body;
+    }
+    async syncStatus(remoteId, folderId, deviceId, options = {}) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.syncStatus, {
+            folderId,
+            deviceId,
+            allErrors: options.allErrors,
+        })).body;
+    }
+    async syncFolderExists(remoteId, folderId) {
+        const response = await this.call(remoteId, host_routes_1.hostRoutes.syncFolderExists, { folderId });
+        return response.status === 200;
+    }
+    async syncRemoteNeed(remoteId, folderId, deviceId) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.syncRemoteNeed, { folderId, deviceId })).body;
+    }
+    async syncInspect(remoteId, input) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.syncInspect, {}, { body: input })).body;
     }
     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);
+        await this.call(remoteId, host_routes_1.hostRoutes.setInstanceLabel, {}, { body: { label } });
     }
     async remoteRuntime(remoteId) {
         const { baseUrl, certificate } = (0, remote_tls_1.requireRemoteTls)(await this.storage.getRemote(remoteId));
@@ -489,235 +410,113 @@ let RemoteHostClient = class RemoteHostClient {
         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');
+        return (await (0, host_transport_1.send)({ baseUrl, certificate, apiKey: null, label: baseUrl }, host_routes_1.hostRoutes.runtimeAt, {}, {
+            timeoutMs: this.runtimeTimeoutMs,
+        })).body;
     }
     async discoverRuntime(origin) {
-        const answer = await (0, remote_discovery_1.discoverRuntime)(origin, RUNTIME_TIMEOUT_MS);
-        const parsed = HostRuntimeSchema.safeParse(answer.body);
+        const answer = await (0, remote_discovery_1.discoverRuntime)(origin, this.runtimeTimeoutMs);
+        const parsed = host_routes_1.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);
+        const response = await (0, host_transport_1.send)({ baseUrl: bootstrapUrl, certificate, apiKey: apiKey ?? null, label: bootstrapUrl }, host_routes_1.hostRoutes.claim, {}, { body });
+        if (response.status === 200)
             return 'claimed';
-        }
-        const code = await readErrorCode(response);
+        const code = response.body;
         if (response.status === 504)
             return 'starting';
         if (code === 'ALREADY_CLAIMED')
             return 'already_claimed';
-        throw new RemoteHostRequestError(`The VM refused the claim${code ? ` (${code})` : ''}.`, {
+        throw new host_transport_1.RemoteHostRequestError(`The VM refused the claim${code ? ` (${code})` : ''}.`, {
             remoteId: bootstrapUrl,
-            path: '/api/host/claim',
+            path: host_routes_1.hostRoutes.claim.path({}),
             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);
+        return (await this.call(remoteId, host_routes_1.hostRoutes.verifyProviderAuth, {}, { body: { provider, opencodeProviderIds } })).body;
     }
     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);
+        await this.call(remoteId, host_routes_1.hostRoutes.applyProviderAuth, {}, { body: bundle });
     }
     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);
+        await this.call(remoteId, host_routes_1.hostRoutes.applySshKeys, {}, { body: { keys } });
     }
     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);
+        const response = await this.call(remoteId, host_routes_1.hostRoutes.requestHostUpdate, {}, { body: { version } });
+        if (response.status === 202)
             return 'started';
-        }
-        const code = await readErrorCode(response);
+        const code = response.body;
         if (code === 'UPDATE_IN_PROGRESS')
             return 'in_progress';
-        throw new RemoteHostRequestError(`The host refused the update${code ? ` (${code})` : ''}.`, {
+        throw new host_transport_1.RemoteHostRequestError(`The host refused the update${code ? ` (${code})` : ''}.`, {
             remoteId,
-            path: '/api/host/update',
+            path: host_routes_1.hostRoutes.requestHostUpdate.path({}),
             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;
+        return (await this.call(remoteId, host_routes_1.hostRoutes.hostUpdateStatus, {})).body.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');
+        return (await this.call(remoteId, host_routes_1.hostRoutes.requestDocker, {}, { body: {} })).body;
     }
     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;
+        return (await this.call(remoteId, host_routes_1.hostRoutes.dockerStatus, {})).body.status;
     }
-    getProviderCliSettingsStatus(remoteId) {
-        return this.hostSettingsRequest(remoteId, '/api/host/provider-clis/status', 'GET', undefined, 200, shared_1.HostProviderCliSettingsStatusSchema, 3000);
+    async getProviderCliSettingsStatus(remoteId) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.getProviderCliSettingsStatus, {})).body;
     }
     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);
+        const route = host_routes_1.hostRoutes.putProviderCliSettings;
+        const response = await this.call(remoteId, route, {}, { body });
+        checkSettingsRevision(remoteId, route.path({}), response, body.revision);
     }
     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);
+        await this.call(remoteId, host_routes_1.hostRoutes.checkProviderClis, {});
     }
-    getSkillSettingsStatus(remoteId) {
-        return this.hostSettingsRequest(remoteId, '/api/host/skill-settings/status', 'GET', undefined, 200, shared_2.HostSkillSettingsStatusSchema, 3000);
+    async getSkillSettingsStatus(remoteId) {
+        return (await this.call(remoteId, host_routes_1.hostRoutes.getSkillSettingsStatus, {})).body;
     }
     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);
+        const route = host_routes_1.hostRoutes.putSkillSettings;
+        const response = await this.call(remoteId, route, {}, { body });
+        checkSettingsRevision(remoteId, route.path({}), response, body.revision);
     }
     async uploadSkillSourceContent(remoteId, name, contentHash, stream, signal) {
-        const path = `/api/host/skill-settings/local-sources/${enc(name)}/content?${new URLSearchParams({ contentHash })}`;
+        const params = { name, 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);
+            const response = await this.call(remoteId, host_routes_1.hostRoutes.uploadSkillSourceContent, params, {
+                body: stream,
+                signal,
+            });
+            if (response.body.name !== name || response.body.contentHash !== contentHash) {
+                throw (0, host_transport_1.invalidHostAnswer)(remoteId, host_routes_1.hostRoutes.uploadSkillSourceContent.path(params), response.status);
+            }
         }
         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])
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Inject)('REMOTE_HOST_RUNTIME_TIMEOUT_MS')),
+    __metadata("design:paramtypes", [Object, remote_api_key_service_1.RemoteApiKeyService, Object])
 ], RemoteHostClient);
-async function discardBody(response) {
-    await response.body?.cancel().catch(() => undefined);
+function checkSettingsRevision(remoteId, path, response, expected) {
+    if (response.body.revision !== expected) {
+        throw (0, host_transport_1.invalidHostAnswer)(remoteId, path, response.status);
+    }
 }
 function parseDockerAnswer(schema, answer, remoteId, path) {
     let value = null;
@@ -726,9 +525,12 @@ function parseDockerAnswer(schema, answer, remoteId, path) {
     }
     catch {
     }
+    return checkDockerAnswer(schema, value, remoteId, path);
+}
+function checkDockerAnswer(schema, value, remoteId, path) {
     const parsed = schema.safeParse(value);
     if (!parsed.success)
-        throw new RemoteHostRequestError('Docker host request failed', {
+        throw new host_transport_1.RemoteHostRequestError('Docker host request failed', {
             remoteId,
             path,
             status: null,
@@ -736,18 +538,6 @@ function parseDockerAnswer(schema, answer, remoteId, path) {
         });
     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)
@@ -757,16 +547,4 @@ function dialAddress(address, baseUrl) {
 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