@interf/compiler 0.7.3 → 0.9.3

package/dist/packages/local-service/client.js

@@ -0,0 +1,356 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { CompileRunCreateRequestSchema, CompileRunListResponseSchema, CompileRunResourceSchema, LocalServiceInstancePointerSchema, LocalJobEventAppendRequestSchema, LocalJobRunCreateRequestSchema, LocalJobRunListResponseSchema, LocalJobRunResourceSchema, LocalServiceHealthSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ReadinessListResponseSchema, TestRunCreateRequestSchema, TestRunListResponseSchema, TestRunResourceSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, } from "./lib/schema.js";
+import { LOCAL_SERVICE_INSTANCE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+export function configuredLocalServiceUrl() {
+    const explicit = process.env.INTERF_SERVICE_URL?.trim();
+    if (explicit)
+        return trimTrailingSlash(explicit);
+    return buildLocalServiceUrl();
+}
+function projectLocalServiceUrl(projectPath) {
+    const pointerPath = join(projectPath, ...LOCAL_SERVICE_INSTANCE_POINTER_PATH);
+    if (!existsSync(pointerPath))
+        return null;
+    try {
+        const pointer = LocalServiceInstancePointerSchema.parse(JSON.parse(readFileSync(pointerPath, "utf8")));
+        return trimTrailingSlash(pointer.service_url);
+    }
+    catch {
+        return null;
+    }
+}
+function localServiceUrlCandidates(projectPath) {
+    const explicit = process.env.INTERF_SERVICE_URL?.trim();
+    if (explicit)
+        return [trimTrailingSlash(explicit)];
+    return Array.from(new Set([
+        projectLocalServiceUrl(projectPath),
+        buildLocalServiceUrl(),
+    ].filter((value) => Boolean(value))));
+}
+async function fetchJson(url, options = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 500);
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+            headers: {
+                ...(options.body ? { "content-type": "application/json" } : {}),
+                ...(options.headers ?? {}),
+            },
+        });
+        if (!response.ok) {
+            const detail = await response.text().catch(() => "");
+            throw new Error(detail || `Interf local service returned HTTP ${response.status}.`);
+        }
+        return await response.json();
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function healthMatchesProject(health, projectPath, explicitServiceUrl) {
+    if (explicitServiceUrl)
+        return true;
+    if (!health.control_path)
+        return true;
+    return resolve(health.control_path) === resolve(projectPath);
+}
+export async function findLocalService(options) {
+    const explicitServiceUrl = Boolean(process.env.INTERF_SERVICE_URL?.trim());
+    for (const serviceUrl of localServiceUrlCandidates(options.projectPath)) {
+        try {
+            const health = LocalServiceHealthSchema.parse(await fetchJson(`${serviceUrl}${LOCAL_SERVICE_ROUTES.health}`, {
+                method: "GET",
+                timeoutMs: options.timeoutMs,
+            }));
+            if (!healthMatchesProject(health, options.projectPath, explicitServiceUrl)) {
+                continue;
+            }
+            return { serviceUrl, health };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export async function submitCompileRunToLocalService(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = CompileRunCreateRequestSchema.parse(options.request);
+    const resource = CompileRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.compileRuns}`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    return {
+        serviceUrl: connection.serviceUrl,
+        resource,
+    };
+}
+export async function submitTestRunToLocalService(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = TestRunCreateRequestSchema.parse(options.request);
+    const resource = TestRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.testRuns}`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    return {
+        serviceUrl: connection.serviceUrl,
+        resource,
+    };
+}
+function isTerminalJobStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "cancelled";
+}
+function isTerminalRunStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "cancelled";
+}
+export async function getLocalCompileRun(options) {
+    return CompileRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.compileRuns}/${encodeURIComponent(options.runId)}`, {
+        method: "GET",
+        timeoutMs: 2000,
+    }));
+}
+export async function listLocalCompileRuns(options) {
+    return CompileRunListResponseSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.compileRuns}`, {
+        method: "GET",
+        timeoutMs: options.timeoutMs ?? 2000,
+    }));
+}
+export async function listLocalReadiness(options) {
+    return ReadinessListResponseSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.readiness}`, {
+        method: "GET",
+        timeoutMs: options.timeoutMs ?? 2000,
+    }));
+}
+export async function waitForLocalCompileRun(options) {
+    const pollMs = options.pollMs ?? 1000;
+    while (true) {
+        const resource = await getLocalCompileRun({
+            serviceUrl: options.serviceUrl,
+            runId: options.runId,
+        });
+        options.onUpdate?.(resource);
+        if (isTerminalRunStatus(resource.run.status))
+            return resource;
+        await new Promise((resolveWait) => setTimeout(resolveWait, pollMs));
+    }
+}
+export async function getLocalTestRun(options) {
+    return TestRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.testRuns}/${encodeURIComponent(options.runId)}`, {
+        method: "GET",
+        timeoutMs: 2000,
+    }));
+}
+export async function listLocalTestRuns(options) {
+    return TestRunListResponseSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.testRuns}`, {
+        method: "GET",
+        timeoutMs: options.timeoutMs ?? 2000,
+    }));
+}
+export async function waitForLocalTestRun(options) {
+    const pollMs = options.pollMs ?? 1000;
+    while (true) {
+        const resource = await getLocalTestRun({
+            serviceUrl: options.serviceUrl,
+            runId: options.runId,
+        });
+        options.onUpdate?.(resource);
+        if (isTerminalRunStatus(resource.status))
+            return resource;
+        await new Promise((resolveWait) => setTimeout(resolveWait, pollMs));
+    }
+}
+export async function getLocalJobRun(options) {
+    return LocalJobRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.jobs}/${encodeURIComponent(options.runId)}`, {
+        method: "GET",
+        timeoutMs: 2000,
+    }));
+}
+export async function listLocalJobRuns(options) {
+    return LocalJobRunListResponseSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.jobs}`, {
+        method: "GET",
+        timeoutMs: options.timeoutMs ?? 2000,
+    }));
+}
+export async function readLocalServiceRunSnapshot(options) {
+    const [jobs, compileRuns, testRuns] = await Promise.all([
+        listLocalJobRuns(options),
+        listLocalCompileRuns(options),
+        listLocalTestRuns(options),
+    ]);
+    return {
+        jobs: jobs.jobs,
+        compileRuns: compileRuns.compile_runs,
+        testRuns: testRuns.test_runs,
+    };
+}
+export async function waitForLocalJobRun(options) {
+    const startedAt = Date.now();
+    const pollMs = options.pollMs ?? 1000;
+    while (true) {
+        const job = await getLocalJobRun({
+            serviceUrl: options.serviceUrl,
+            runId: options.runId,
+        });
+        options.onUpdate?.(job);
+        if (isTerminalJobStatus(job.status))
+            return job;
+        if (options.timeoutMs && Date.now() - startedAt > options.timeoutMs) {
+            throw new Error(`Timed out waiting for local job ${options.runId}.`);
+        }
+        await new Promise((resolveWait) => setTimeout(resolveWait, pollMs));
+    }
+}
+function resultError(job, defaultMessage) {
+    for (let index = job.events.length - 1; index >= 0; index -= 1) {
+        const event = job.events[index];
+        if (event?.type === "job.failed" && event.message)
+            return event.message;
+    }
+    return job.error ?? defaultMessage;
+}
+export async function submitReadinessCheckDraftToLocalService(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = ReadinessCheckDraftCreateRequestSchema.parse(options.request);
+    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.readinessCheckDrafts}`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    options.onSubmitted?.({
+        serviceUrl: connection.serviceUrl,
+        job: initialJob,
+    });
+    const job = await waitForLocalJobRun({
+        serviceUrl: connection.serviceUrl,
+        runId: initialJob.run_id,
+        onUpdate: options.onUpdate,
+    });
+    if (job.status !== "succeeded") {
+        return {
+            serviceUrl: connection.serviceUrl,
+            job,
+            result: null,
+            error: resultError(job, "Readiness-check drafting failed in the local Interf service."),
+        };
+    }
+    const parsed = ReadinessCheckDraftResultSchema.safeParse(job.result);
+    if (!parsed.success) {
+        return {
+            serviceUrl: connection.serviceUrl,
+            job,
+            result: null,
+            error: "Readiness-check drafting finished without a valid result.",
+        };
+    }
+    return {
+        serviceUrl: connection.serviceUrl,
+        job,
+        result: parsed.data,
+    };
+}
+export async function submitMethodAuthoringRunToLocalService(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = MethodAuthoringCreateRequestSchema.parse(options.request);
+    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.methodAuthoringRuns}`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    options.onSubmitted?.({
+        serviceUrl: connection.serviceUrl,
+        job: initialJob,
+    });
+    const job = await waitForLocalJobRun({
+        serviceUrl: connection.serviceUrl,
+        runId: initialJob.run_id,
+        onUpdate: options.onUpdate,
+    });
+    if (job.status !== "succeeded") {
+        return {
+            serviceUrl: connection.serviceUrl,
+            job,
+            result: null,
+            error: resultError(job, "Method authoring failed in the local Interf service."),
+        };
+    }
+    const parsed = MethodAuthoringResultSchema.safeParse(job.result);
+    if (!parsed.success) {
+        return {
+            serviceUrl: connection.serviceUrl,
+            job,
+            result: null,
+            error: "Method authoring finished without a valid result.",
+        };
+    }
+    return {
+        serviceUrl: connection.serviceUrl,
+        job,
+        result: parsed.data,
+    };
+}
+export async function appendLocalJobRunEvent(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const event = LocalJobEventAppendRequestSchema.parse(options.event);
+    return LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.jobs}/${encodeURIComponent(options.runId)}/events`, {
+        method: "POST",
+        body: JSON.stringify(event),
+    }));
+}
+export async function startLocalJobRun(options) {
+    const connection = await findLocalService({ projectPath: options.projectPath });
+    if (!connection)
+        return null;
+    const request = LocalJobRunCreateRequestSchema.parse(options.request);
+    const resource = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.jobs}`, {
+        method: "POST",
+        body: JSON.stringify(request),
+    }));
+    const emit = (event) => {
+        void appendLocalJobRunEvent({
+            projectPath: options.projectPath,
+            runId: resource.run_id,
+            event,
+        }).catch(() => { });
+    };
+    return {
+        serviceUrl: connection.serviceUrl,
+        runId: resource.run_id,
+        resource,
+        emit,
+        complete: async (message) => {
+            await appendLocalJobRunEvent({
+                projectPath: options.projectPath,
+                runId: resource.run_id,
+                event: {
+                    type: "job.completed",
+                    ...(message ? { message } : {}),
+                },
+            });
+        },
+        fail: async (message) => {
+            await appendLocalJobRunEvent({
+                projectPath: options.projectPath,
+                runId: resource.run_id,
+                event: {
+                    type: "job.failed",
+                    message,
+                },
+            });
+        },
+    };
+}

package/dist/packages/local-service/index.d.ts

@@ -0,0 +1,15 @@
+export * as schema from "./lib/schema.js";
+export * as actionValues from "./action-values.js";
+export * as routes from "./routes.js";
+export * as client from "./client.js";
+export * as runtime from "./runtime.js";
+export * as server from "./server.js";
+export type { CompileRunCreateRequest, CompileRunResource, CompileRunSummary, LocalServiceDiscovery, PortableContextMapping, PreparationReadinessState, PreparationRunLinkage, PreparationResource, MethodResource, LocalJobAgent, LocalJobEvent, LocalJobEventAppendRequest, LocalJobEventType, LocalJobRunCreateRequest, LocalJobRunListResponse, LocalJobRunResource, LocalJobStatus, LocalRunHandlerResult, LocalJobStep, LocalJobType, LocalServiceConfig, LocalServiceHealth, LocalServiceInstancePointer, LocalServiceResource, LocalExecutorStatus, ActionProposalApproval, ActionProposalApprovalRequest, ActionProposalCreateRequest, ActionProposalListResponse, ActionProposalPlan, ActionProposalResource, ActionProposalStatus, ActionProposalType, PreparationSetupCreateRequest, PortableContextResource, ReadinessListResponse, ReadinessResource, SourceFileResource, WorkspaceFileResource, ReadinessCheckDraftCreateRequest, ReadinessCheckDraftResult, TestRunCreateRequest, TestRunResource, TestRunStatus, RunCreateRequest, RunObservabilityListResponse, RunObservabilityResource, MethodAuthoringCreateRequest, MethodAuthoringResult, PreparationListResponse, MethodListResponse, CompileRunListResponse, TestRunListResponse, PortableContextListResponse, SourceFileListResponse, WorkspaceFileListResponse, OpenPathRequest, OpenPathResponse, } from "./lib/schema.js";
+export { CompileRunCreateRequestSchema, CompileRunResourceSchema, CompileRunSummarySchema, LocalServiceDiscoverySchema, PortableContextMappingSchema, PreparationReadinessStateSchema, PreparationRunLinkageSchema, PreparationResourceSchema, MethodResourceSchema, LocalJobAgentSchema, LocalJobEventAppendRequestSchema, LocalJobEventSchema, LocalJobEventTypeSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, LocalJobStatusSchema, LocalRunHandlerResultSchema, LocalJobStepSchema, LocalJobTypeSchema, LocalServiceConfigSchema, LocalServiceHealthSchema, LocalServiceInstancePointerSchema, LocalServiceResourceSchema, PortableContextResourceSchema, ReadinessResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, TestRunCreateRequestSchema, TestRunResourceSchema, TestRunStatusSchema, RunCreateRequestSchema, RunObservabilityResourceSchema, RunObservabilityListResponseSchema, LocalExecutorStatusSchema, ActionProposalApprovalRequestSchema, ActionProposalApprovalSchema, ActionProposalCreateRequestSchema, ActionProposalListResponseSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, ActionProposalStatusSchema, ActionProposalTypeSchema, PreparationSetupCreateRequestSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, PreparationListResponseSchema, MethodListResponseSchema, CompileRunListResponseSchema, LocalJobRunListResponseSchema, TestRunListResponseSchema, PortableContextListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, WorkspaceFileListResponseSchema, OpenPathRequestSchema, OpenPathResponseSchema, } from "./lib/schema.js";
+export { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_INSTANCE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
+export type { LocalServiceJobSubmission, LocalServiceJobSubmitted, LocalServiceConnection, LocalServiceRunSnapshot, LocalJobTracker, } from "./client.js";
+export { appendLocalJobRunEvent, configuredLocalServiceUrl, findLocalService, getLocalJobRun, getLocalCompileRun, getLocalTestRun, listLocalCompileRuns, listLocalJobRuns, listLocalTestRuns, readLocalServiceRunSnapshot, startLocalJobRun, submitCompileRunToLocalService, submitReadinessCheckDraftToLocalService, submitTestRunToLocalService, submitMethodAuthoringRunToLocalService, waitForLocalJobRun, waitForLocalCompileRun, waitForLocalTestRun, } from "./client.js";
+export type { LocalServiceActionPlanningContext, LocalServiceCompileRunContext, LocalServiceJobRunContext, LocalServiceRunHandlers, LocalServiceRuntimeOptions, LocalServiceTestRunContext, } from "./runtime.js";
+export { LocalServiceRuntime, createLocalServiceRuntime, } from "./runtime.js";
+export type { StartedLocalService, StartLocalServiceOptions, } from "./server.js";
+export { createLocalServiceServer, startLocalService, } from "./server.js";

package/dist/packages/local-service/index.js

@@ -0,0 +1,11 @@
+export * as schema from "./lib/schema.js";
+export * as actionValues from "./action-values.js";
+export * as routes from "./routes.js";
+export * as client from "./client.js";
+export * as runtime from "./runtime.js";
+export * as server from "./server.js";
+export { CompileRunCreateRequestSchema, CompileRunResourceSchema, CompileRunSummarySchema, LocalServiceDiscoverySchema, PortableContextMappingSchema, PreparationReadinessStateSchema, PreparationRunLinkageSchema, PreparationResourceSchema, MethodResourceSchema, LocalJobAgentSchema, LocalJobEventAppendRequestSchema, LocalJobEventSchema, LocalJobEventTypeSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, LocalJobStatusSchema, LocalRunHandlerResultSchema, LocalJobStepSchema, LocalJobTypeSchema, LocalServiceConfigSchema, LocalServiceHealthSchema, LocalServiceInstancePointerSchema, LocalServiceResourceSchema, PortableContextResourceSchema, ReadinessResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, TestRunCreateRequestSchema, TestRunResourceSchema, TestRunStatusSchema, RunCreateRequestSchema, RunObservabilityResourceSchema, RunObservabilityListResponseSchema, LocalExecutorStatusSchema, ActionProposalApprovalRequestSchema, ActionProposalApprovalSchema, ActionProposalCreateRequestSchema, ActionProposalListResponseSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, ActionProposalStatusSchema, ActionProposalTypeSchema, PreparationSetupCreateRequestSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, PreparationListResponseSchema, MethodListResponseSchema, CompileRunListResponseSchema, LocalJobRunListResponseSchema, TestRunListResponseSchema, PortableContextListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, WorkspaceFileListResponseSchema, OpenPathRequestSchema, OpenPathResponseSchema, } from "./lib/schema.js";
+export { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_INSTANCE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
+export { appendLocalJobRunEvent, configuredLocalServiceUrl, findLocalService, getLocalJobRun, getLocalCompileRun, getLocalTestRun, listLocalCompileRuns, listLocalJobRuns, listLocalTestRuns, readLocalServiceRunSnapshot, startLocalJobRun, submitCompileRunToLocalService, submitReadinessCheckDraftToLocalService, submitTestRunToLocalService, submitMethodAuthoringRunToLocalService, waitForLocalJobRun, waitForLocalCompileRun, waitForLocalTestRun, } from "./client.js";
+export { LocalServiceRuntime, createLocalServiceRuntime, } from "./runtime.js";
+export { createLocalServiceServer, startLocalService, } from "./server.js";