@interf/compiler 0.9.4 → 0.13.0

package/dist/packages/local-service/lib/schema.js

@@ -4,12 +4,122 @@ import { SourcePreparationConfigSchema, SourceReadinessCheckSchema, } from "../.
 import { PreparationNameSchema, ReadinessStateSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, MethodIdSchema, } from "../../contracts/lib/schema.js";
 import { ReadinessCheckRunSchema, TestRunModeSchema, } from "../../testing/lib/schema.js";
 const JsonObjectSchema = z.record(z.string(), z.unknown());
-export const LocalServiceHostSchema = z.string().min(1);
+// ───────────────────────────────────────────────────────────────────────────
+// 0.13 — preparation-first additions
+// ───────────────────────────────────────────────────────────────────────────
+/** Source binding shape on the API (only `local-folder` ships in 0.13). */
+export const SourceBindingSchema = z.object({
+    kind: z.enum(["local-folder"]),
+    locator: z.string().min(1),
+}).strict();
+/** Discriminated locator for an artifact returned by the API. */
+export const ArtifactLocatorSchema = z.object({
+    kind: z.enum(["local-path", "remote-url"]),
+    value: z.string().min(1),
+}).strict();
+/** Per-instance metadata from `GET /v1/instance` (replaces /v1/status). */
+export const InstanceResourceSchema = z.object({
+    kind: z.literal("interf-instance"),
+    version: z.literal(1),
+    url: z.string().min(1),
+    host: z.string().min(1),
+    port: z.number().int().min(1).max(65535),
+    started_at: z.string().min(1),
+    package_version: z.string().min(1).optional(),
+    preparation_count: z.number().int().min(0),
+    active_run_count: z.number().int().min(0),
+    idle_for_seconds: z.number().int().min(0),
+    auth_required: z.boolean(),
+}).strict();
+/** Body of `POST /v1/preparations` — the 0.13 preparation create request. */
+export const PreparationCreateRequestSchema = z.object({
+    id: PreparationNameSchema,
+    source: SourceBindingSchema,
+    method_id: MethodIdSchema,
+    about: z.string().min(1).optional(),
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
+    max_loops: SourceCompiledMaxLoopsSchema.optional(),
+}).strict();
+/** Body of `POST /v1/methods` — install a Method package by path. */
+export const MethodInstallRequestSchema = z.object({
+    source_path: z.string().min(1),
+    overwrite: z.boolean().default(false),
+}).strict();
+export const MethodInstallResultSchema = z.object({
+    method_id: MethodIdSchema,
+    installed: z.boolean(),
+    path: z.string().min(1),
+}).strict();
+export const PreparationDeleteResponseSchema = z.object({
+    deleted: z.boolean(),
+    id: PreparationNameSchema,
+}).strict();
+/**
+ * The local service must only ever bind to a loopback interface. Any other
+ * host (LAN IP, 0.0.0.0, public address) lets a remote browser tab POST at
+ * the service, which is the CSRF model we are explicitly rejecting. Keep
+ * the allowlist literal — refactoring to a `.refine()` over `z.string()`
+ * would lose the static type narrowing.
+ */
+export const LOCAL_SERVICE_LOOPBACK_HOSTS = ["127.0.0.1", "localhost", "::1"];
+export const LocalServiceHostSchema = z
+    .string()
+    .min(1)
+    .refine((value) => LOCAL_SERVICE_LOOPBACK_HOSTS.includes(value), {
+    message: `Local service host must be one of: ${LOCAL_SERVICE_LOOPBACK_HOSTS.join(", ")}.`,
+});
 export const LocalServicePortSchema = z.number().int().min(1).max(65535);
+/**
+ * Per-instance bearer token. Generated at startup with crypto.randomBytes(32)
+ * and rendered as a 64-char hex string. Any deviation should fail validation
+ * loud and early.
+ */
+export const LocalServiceAuthTokenSchema = z
+    .string()
+    .regex(/^[0-9a-f]{64}$/i, "Auth token must be a 64-character hex string.");
 export const LocalServiceConfigSchema = z.object({
     host: LocalServiceHostSchema.default("127.0.0.1"),
     port: LocalServicePortSchema.default(4873),
 }).strict();
+export const ServiceRegistryWorkspaceSchema = z.object({
+    control_path: z.string().min(1),
+    registered_at: z.string().min(1),
+    last_activity: z.string().min(1),
+}).strict();
+export const ServiceRegistryEntrySchema = z.object({
+    pid: z.number().int().positive(),
+    host: LocalServiceHostSchema,
+    port: LocalServicePortSchema,
+    url: z.string().min(1),
+    started_at: z.string().min(1),
+    /**
+     * Bearer token mutating clients must send. Optional in the schema so
+     * older registry files (pre-0.12.1) keep parsing; the runtime treats a
+     * missing token as "open" only when the entry already exists on disk —
+     * fresh entries always have one.
+     */
+    auth_token: LocalServiceAuthTokenSchema.optional(),
+    workspaces: z.array(ServiceRegistryWorkspaceSchema).default([]),
+}).strict();
+export const ServiceRegistrySchema = z.object({
+    services: z.array(ServiceRegistryEntrySchema).default([]),
+}).strict();
+export const WorkspaceRegistrationRequestSchema = z.object({
+    control_path: z.string().min(1),
+}).strict();
+export const WorkspaceRegistrationResponseSchema = z.object({
+    workspace: ServiceRegistryWorkspaceSchema,
+    service: ServiceRegistryEntrySchema,
+}).strict();
+export const WorkspaceListResponseSchema = z.object({
+    workspaces: z.array(ServiceRegistryWorkspaceSchema),
+}).strict();
+export const WorkspaceDeregisterResponseSchema = z.object({
+    deregistered: z.boolean(),
+    control_path: z.string().min(1),
+    remaining_workspaces: z.number().int().min(0),
+}).strict();
 export const LocalServiceHealthSchema = z.object({
     kind: z.literal("interf-local-service-health"),
     version: z.literal(1),
@@ -21,16 +131,30 @@ export const LocalServiceHealthSchema = z.object({
     source_folder_path: z.string().min(1).nullable().optional(),
     started_at: z.string().min(1).optional(),
     package_version: z.string().min(1).optional(),
+    instance_started_at: z.string().min(1).optional(),
+    registered_workspaces: z.array(ServiceRegistryWorkspaceSchema).default([]),
+    active_runs: z.number().int().min(0).default(0),
+    idle_for_seconds: z.number().int().min(0).default(0),
+}).strict();
+export const LocalServiceErrorSchema = z.object({
+    error: z.object({
+        message: z.string().min(1),
+        code: z.string().min(1).optional(),
+    }).strict(),
 }).strict();
-export const LocalServiceInstancePointerSchema = z.object({
+export const LocalServicePointerSchema = z.object({
     service_url: z.string().min(1),
     host: LocalServiceHostSchema,
     port: LocalServicePortSchema,
     pid: z.number().int().positive(),
     control_path: z.string().min(1),
     started_at: z.string().min(1),
+    /**
+     * Per-workspace copy of the bearer token. Optional so legacy pointer
+     * files keep parsing during upgrades; new pointers always include it.
+     */
+    auth_token: LocalServiceAuthTokenSchema.optional(),
 }).strict();
-export const PreparationReadinessStateSchema = ReadinessStateSchema;
 export const PortableContextMappingSchema = z.object({
     preparation: PreparationNameSchema,
     path: z.string().min(1).nullable(),
@@ -52,7 +176,7 @@ export const PreparationResourceSchema = z.object({
     checks: z.array(SourceReadinessCheckSchema).default([]),
     portable_context: PortableContextMappingSchema,
     portable_context_path: z.string().min(1).nullable(),
-    readiness: PreparationReadinessStateSchema,
+    readiness: ReadinessStateSchema,
     runs: PreparationRunLinkageSchema,
     latest_compile_run_id: z.string().min(1).nullable().optional(),
     latest_test_run_id: z.string().min(1).nullable().optional(),
@@ -66,6 +190,7 @@ export const MethodResourceSchema = z.object({
     source_kind: z.enum(["builtin", "local"]).default("local"),
     built_in: z.boolean().default(false),
     active_for_preparations: z.array(PreparationNameSchema).default([]),
+    output_paths: z.array(z.string().min(1)).default([]),
     stages: z.array(z.object({
         id: z.string().min(1),
         label: z.string().min(1),
@@ -99,24 +224,22 @@ export const CompileRunResourceSchema = z.object({
     run: CompileRunSchema,
 }).strict();
 export const LocalJobTypeSchema = z.enum([
-    "preparation-setup",
     "readiness-check-draft",
     "method-authoring",
     "method-improvement",
-    "compile",
-    "test",
 ]);
-export const LocalJobStatusSchema = z.enum([
+export const RunStatusSchema = z.enum([
     "queued",
     "running",
     "succeeded",
     "failed",
     "cancelled",
 ]);
+export const LocalJobStatusSchema = RunStatusSchema;
 export const LocalRunHandlerResultSchema = z.object({
     ok: z.boolean(),
     error: z.string().min(1).optional(),
-    comparison: ReadinessCheckRunSchema.nullable().optional(),
+    readiness_run: ReadinessCheckRunSchema.nullable().optional(),
 }).strict();
 export const LocalJobAgentSchema = z.object({
     name: z.string().min(1),
@@ -174,6 +297,98 @@ export const LocalJobRunCreateRequestSchema = z.object({
 export const PreparationSetupCreateRequestSchema = z.object({
     preparation: SourcePreparationConfigSchema,
     prepare_after_setup: z.boolean().default(false),
+    setup_mode: z.enum(["create", "select-method"]).default("create"),
+}).strict();
+export const PreparationSetupResultSchema = z.object({
+    kind: z.literal("interf-preparation-setup-result"),
+    version: z.literal(1),
+    operation: z.enum(["create", "select-method"]),
+    preparation: PreparationNameSchema,
+    method: MethodIdSchema,
+    source_folder_path: z.string().min(1),
+    config_path: z.string().min(1),
+    portable_context_path: z.string().min(1),
+    changed: z.boolean(),
+    message: z.string().min(1),
+    submitted_run_id: z.string().min(1).nullable().optional(),
+    submitted_run_type: z.literal("compile-run").nullable().optional(),
+}).strict();
+export const WorkspaceBootstrapCreateRequestSchema = z.object({
+    source_folder: z.object({
+        path: z.string().min(1),
+    }).strict().optional(),
+    seed_default_method: z.boolean().default(true),
+}).strict();
+export const WorkspaceBootstrapResultSchema = z.object({
+    kind: z.literal("interf-workspace-bootstrap-result"),
+    version: z.literal(1),
+    control_path: z.string().min(1),
+    config_path: z.string().min(1),
+    source_folder_path: z.string().min(1).nullable(),
+    preparations: z.number().int().min(0),
+    seeded_default_method: z.boolean(),
+    default_method_id: MethodIdSchema.nullable(),
+    changed: z.boolean(),
+    message: z.string().min(1),
+}).strict();
+export const MethodChangeCreateRequestSchema = z.discriminatedUnion("operation", [
+    z.object({
+        action_type: z.literal("method-change").optional(),
+        operation: z.literal("duplicate"),
+        method: MethodIdSchema,
+        new_method_id: MethodIdSchema,
+        label: z.string().min(1).optional(),
+        hint: z.string().min(1).optional(),
+    }).strict(),
+    z.object({
+        action_type: z.literal("method-change").optional(),
+        operation: z.literal("remove"),
+        method: MethodIdSchema,
+        confirmation: MethodIdSchema,
+    }).strict(),
+]);
+export const MethodChangeResultSchema = z.object({
+    kind: z.literal("interf-method-change-result"),
+    version: z.literal(1),
+    operation: z.enum(["duplicate", "remove"]),
+    method: MethodIdSchema,
+    new_method_id: MethodIdSchema.nullable().optional(),
+    updated_preparations: z.array(PreparationNameSchema).default([]),
+    method_path: z.string().min(1),
+    changed: z.boolean(),
+    message: z.string().min(1),
+}).strict();
+export const PreparationChangeCreateRequestSchema = z.discriminatedUnion("operation", [
+    z.object({
+        action_type: z.literal("preparation-change").optional(),
+        operation: z.literal("remove"),
+        preparation: PreparationNameSchema,
+        confirmation: PreparationNameSchema,
+    }).strict(),
+]);
+export const PreparationChangeResultSchema = z.object({
+    kind: z.literal("interf-preparation-change-result"),
+    version: z.literal(1),
+    operation: z.literal("remove"),
+    preparation: PreparationNameSchema,
+    config_path: z.string().min(1),
+    portable_context_path: z.string().min(1),
+    portable_context_retained: z.boolean(),
+    changed: z.boolean(),
+    message: z.string().min(1),
+}).strict();
+export const ResetRequestSchema = z.object({
+    preparation: PreparationNameSchema,
+    scope: z.enum(["compile", "all"]),
+}).strict();
+export const ResetResultSchema = z.object({
+    kind: z.literal("interf-reset-result"),
+    version: z.literal(1),
+    preparation: PreparationNameSchema,
+    scope: z.enum(["compile", "all"]),
+    portable_context_path: z.string().min(1),
+    changed: z.boolean(),
+    message: z.string().min(1),
 }).strict();
 export const ReadinessCheckDraftCreateRequestSchema = z.object({
     preparation: PreparationNameSchema,
@@ -231,13 +446,7 @@ export const LocalJobRunResourceSchema = z.object({
     result: z.record(z.string(), z.unknown()).nullable().optional(),
     error: z.string().min(1).nullable().optional(),
 }).strict();
-export const TestRunStatusSchema = z.enum([
-    "queued",
-    "running",
-    "succeeded",
-    "failed",
-    "cancelled",
-]);
+export const TestRunStatusSchema = RunStatusSchema;
 export const TestRunCreateRequestSchema = z.object({
     preparation: PreparationNameSchema,
     mode: TestRunModeSchema.default("both"),
@@ -251,40 +460,12 @@ export const TestRunResourceSchema = z.object({
     portable_context_path: z.string().min(1).nullable(),
     started_at: z.string().nullable().optional(),
     finished_at: z.string().nullable().optional(),
-    comparison: ReadinessCheckRunSchema.nullable(),
+    readiness_run: ReadinessCheckRunSchema.nullable(),
     readiness: ReadinessStateSchema.nullable().optional(),
     events: z.array(InterfRunEventSchema).default([]),
     error: z.string().min(1).nullable().optional(),
 }).strict();
 export const RunObservabilityResourceSchema = RunObservabilitySchema;
-export const RunCreateRequestSchema = z.discriminatedUnion("run_type", [
-    z.object({
-        run_type: z.literal("compile"),
-        preparation: PreparationNameSchema,
-        method: MethodIdSchema.optional(),
-        max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-        max_loops: SourceCompiledMaxLoopsSchema.optional(),
-        preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
-    }).strict(),
-    z.object({
-        run_type: z.literal("prepare"),
-        preparation: PreparationNameSchema,
-        method: MethodIdSchema.optional(),
-        max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-        max_loops: SourceCompiledMaxLoopsSchema.optional(),
-        preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
-    }).strict(),
-    z.object({
-        run_type: z.literal("test"),
-        preparation: PreparationNameSchema,
-        mode: TestRunModeSchema.default("both"),
-    }).strict(),
-    z.object({
-        run_type: z.literal("check"),
-        preparation: PreparationNameSchema,
-        mode: TestRunModeSchema.default("both"),
-    }).strict(),
-]);
 export const LocalExecutorStatusSchema = z.object({
     kind: z.literal("interf-local-executor-status"),
     version: z.literal(1),
@@ -298,10 +479,20 @@ export const LocalExecutorSelectRequestSchema = z.object({
     agent: z.string().min(1),
 }).strict();
 export const ActionProposalTypeSchema = z.enum([
+    "clarification",
+    "readiness-check-draft",
+    "method-authoring",
+    "method-improvement",
+    "compile",
+    "test",
+]);
+export const ActionProposalPlanActionTypeSchema = z.enum([
     "clarification",
     "preparation-setup",
+    "preparation-change",
     "readiness-check-draft",
     "method-authoring",
+    "method-change",
     "method-improvement",
     "compile",
     "test",
@@ -314,13 +505,22 @@ export const ActionProposalStatusSchema = z.enum([
     "submitted",
     "failed",
 ]);
+export const ActionClientOriginSchema = z.enum([
+    "ui-chat",
+    "cli",
+    "agent-cli",
+    "mcp",
+    "service",
+    "unknown",
+]);
 export const ActionProposalCreateRequestSchema = z.object({
     message: z.string().min(1),
     preparation: PreparationNameSchema.optional(),
+    client_origin: ActionClientOriginSchema.default("unknown"),
     values: JsonObjectSchema.optional(),
 }).strict();
 export const ActionProposalPlanSchema = z.object({
-    action_type: ActionProposalTypeSchema,
+    action_type: ActionProposalPlanActionTypeSchema,
     preparation: PreparationNameSchema.optional(),
     method: MethodIdSchema.optional(),
     values: JsonObjectSchema.optional(),
@@ -350,6 +550,7 @@ const ActionProposalResourceBaseSchema = z.object({
     message: z.string().min(1),
     preparation: PreparationNameSchema.nullable().optional(),
     method: MethodIdSchema.nullable().optional(),
+    client_origin: ActionClientOriginSchema.default("unknown"),
     created_at: z.string().min(1),
     updated_at: z.string().min(1),
     proposed_by_executor: LocalJobAgentSchema.nullable().optional(),
@@ -367,10 +568,6 @@ export const ActionProposalResourceSchema = z.discriminatedUnion("action_type",
         action_type: z.literal("compile"),
         request: CompileRunCreateRequestSchema,
     }).strict(),
-    ActionProposalResourceBaseSchema.extend({
-        action_type: z.literal("preparation-setup"),
-        request: PreparationSetupCreateRequestSchema,
-    }).strict(),
     ActionProposalResourceBaseSchema.extend({
         action_type: z.literal("test"),
         request: TestRunCreateRequestSchema,
@@ -398,7 +595,7 @@ export const PortableContextResourceSchema = z.object({
     latest_test_run_id: z.string().min(1).nullable().optional(),
     artifacts: z.array(ArtifactRefSchema).default([]),
 }).strict();
-export const ReadinessResourceSchema = PreparationReadinessStateSchema;
+export const ReadinessResourceSchema = ReadinessStateSchema;
 export const SourceFileResourceSchema = z.object({
     preparation: PreparationNameSchema,
     path: z.string().min(1),
@@ -425,7 +622,19 @@ export const LocalServiceDiscoverySchema = z.object({
         source_files: z.string().min(1),
         workspace_files: z.string().min(1),
         action_proposals: z.string().min(1),
+        preparation_setups: z.string().min(1),
+        preparation_changes: z.string().min(1),
+        method_changes: z.string().min(1),
+        workspace_bootstraps: z.string().min(1).optional(),
+        readiness_check_drafts: z.string().min(1),
+        method_authoring_runs: z.string().min(1),
+        method_improvement_runs: z.string().min(1),
+        compile_runs: z.string().min(1),
+        test_runs: z.string().min(1),
+        reset: z.string().min(1),
         executor: z.string().min(1),
+        workspaces: z.string().min(1).optional(),
+        status: z.string().min(1).optional(),
     }).strict(),
 }).strict();
 export const OpenPathRequestSchema = z.object({
@@ -435,56 +644,6 @@ export const OpenPathResponseSchema = z.object({
     opened: z.boolean(),
     path: z.string().min(1),
 }).strict();
-export const LocalServiceResourceSchema = z.discriminatedUnion("kind", [
-    z.object({
-        kind: z.literal("preparation"),
-        value: PreparationResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("method"),
-        value: MethodResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("compile-run"),
-        value: CompileRunResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("job-run"),
-        value: LocalJobRunResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("test-run"),
-        value: TestRunResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("run-observability"),
-        value: RunObservabilityResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("executor-status"),
-        value: LocalExecutorStatusSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("action-proposal"),
-        value: ActionProposalResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("portable-context"),
-        value: PortableContextResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("readiness"),
-        value: ReadinessResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("source-file"),
-        value: SourceFileResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("workspace-file"),
-        value: WorkspaceFileResourceSchema,
-    }).strict(),
-]);
 export const PreparationListResponseSchema = z.object({
     preparations: z.array(PreparationResourceSchema),
 }).strict();

package/dist/packages/local-service/native-run-handlers.d.ts

@@ -0,0 +1,23 @@
+import type { MethodExecutionProfile, MethodExecutor } from "../agents/lib/executors.js";
+import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
+import type { StageShellRetentionMode } from "../compiler/method-runs.js";
+import type { RunEventSink } from "../execution/events.js";
+import type { LocalServiceRunHandlers } from "./runtime.js";
+export interface NativeLocalServiceRunHandlerOptions {
+    executor?: MethodExecutor;
+    testExecutor?: MethodExecutor;
+}
+export declare function runConfiguredCompiledCompile(options: {
+    executor: MethodExecutor;
+    testExecutor?: MethodExecutor | null;
+    compiledPath: string;
+    sourcePath: string;
+    compiledConfig: SourcePreparationConfig | null;
+    executionProfile?: MethodExecutionProfile;
+    maxAttemptsOverride: number | null;
+    maxLoopsOverride: number | null;
+    preserveStageShells?: StageShellRetentionMode;
+    runId?: string;
+    events?: RunEventSink;
+}): Promise<boolean>;
+export declare function createNativeLocalServiceRunHandlers(options?: NativeLocalServiceRunHandlerOptions): Pick<LocalServiceRunHandlers, "planActionProposal" | "createCompileRun" | "createTestRun" | "createReadinessCheckDraft" | "createMethodAuthoringRun">;