@playcraft/common 0.1.70 → 0.1.72
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cloud-workspace/runtime/batch-runs.d.ts +126 -0
- package/dist/cloud-workspace/runtime/batch-runs.d.ts.map +1 -1
- package/dist/cloud-workspace/runtime/batch-runs.js +180 -58
- package/dist/cloud-workspace/runtime/batch-runs.js.map +1 -1
- package/dist/cloud-workspace/runtime/execution-admission.d.ts +20 -0
- package/dist/cloud-workspace/runtime/execution-admission.d.ts.map +1 -1
- package/dist/cloud-workspace/runtime/execution-admission.js +111 -27
- package/dist/cloud-workspace/runtime/execution-admission.js.map +1 -1
- package/dist/cloud-workspace/runtime/execution-grant.d.ts +21 -1
- package/dist/cloud-workspace/runtime/execution-grant.d.ts.map +1 -1
- package/dist/cloud-workspace/runtime/execution-grant.js +13 -0
- package/dist/cloud-workspace/runtime/execution-grant.js.map +1 -1
- package/dist/cloud-workspace/runtime/files.d.ts +1 -0
- package/dist/cloud-workspace/runtime/files.d.ts.map +1 -1
- package/dist/cloud-workspace/runtime/files.js +58 -18
- package/dist/cloud-workspace/runtime/files.js.map +1 -1
- package/dist/cloud-workspace/runtime/index.d.ts +2 -1
- package/dist/cloud-workspace/runtime/index.d.ts.map +1 -1
- package/dist/cloud-workspace/runtime/index.js +2 -1
- package/dist/cloud-workspace/runtime/index.js.map +1 -1
- package/dist/cloud-workspace/runtime/operations.d.ts +29 -4
- package/dist/cloud-workspace/runtime/operations.d.ts.map +1 -1
- package/dist/cloud-workspace/runtime/operations.js +5 -0
- package/dist/cloud-workspace/runtime/operations.js.map +1 -1
- package/dist/cloud-workspace/runtime/remix-references.d.ts +98 -12
- package/dist/cloud-workspace/runtime/remix-references.d.ts.map +1 -1
- package/dist/cloud-workspace/runtime/remix-references.js +194 -56
- package/dist/cloud-workspace/runtime/remix-references.js.map +1 -1
- package/dist/cloud-workspace/runtime/skill-activation.d.ts +126 -0
- package/dist/cloud-workspace/runtime/skill-activation.d.ts.map +1 -0
- package/dist/cloud-workspace/runtime/skill-activation.js +42 -0
- package/dist/cloud-workspace/runtime/skill-activation.js.map +1 -0
- package/dist/model-proxy/diagnostics.d.ts +8 -0
- package/dist/model-proxy/diagnostics.d.ts.map +1 -1
- package/dist/model-proxy/index.d.ts +2 -0
- package/dist/model-proxy/index.d.ts.map +1 -1
- package/dist/model-proxy/index.js +2 -0
- package/dist/model-proxy/index.js.map +1 -1
- package/dist/model-proxy/request-journey.d.ts +162 -0
- package/dist/model-proxy/request-journey.d.ts.map +1 -0
- package/dist/model-proxy/request-journey.js +75 -0
- package/dist/model-proxy/request-journey.js.map +1 -0
- package/dist/model-proxy/user-requests.d.ts +32 -0
- package/dist/model-proxy/user-requests.d.ts.map +1 -0
- package/dist/model-proxy/user-requests.js +2 -0
- package/dist/model-proxy/user-requests.js.map +1 -0
- package/dist/project-skills/index.d.ts +1 -0
- package/dist/project-skills/index.d.ts.map +1 -1
- package/dist/project-skills/index.js +1 -0
- package/dist/project-skills/index.js.map +1 -1
- package/dist/project-skills/remote-discovery.d.ts +101 -0
- package/dist/project-skills/remote-discovery.d.ts.map +1 -0
- package/dist/project-skills/remote-discovery.js +56 -0
- package/dist/project-skills/remote-discovery.js.map +1 -0
- package/package.json +1 -1
|
@@ -82,6 +82,26 @@ export declare const sandboxBatchSourceFreezeRequestSchema: z.ZodObject<{
|
|
|
82
82
|
}>;
|
|
83
83
|
resumeOnly: z.ZodOptional<z.ZodBoolean>;
|
|
84
84
|
deadline: z.ZodOptional<z.ZodString>;
|
|
85
|
+
starterTemplate: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
|
|
86
|
+
snapshot: z.ZodObject<{
|
|
87
|
+
templateId: z.ZodString;
|
|
88
|
+
commit: z.ZodString;
|
|
89
|
+
files: z.ZodArray<z.ZodObject<{
|
|
90
|
+
path: z.ZodString;
|
|
91
|
+
content: z.ZodString;
|
|
92
|
+
sha256: z.ZodString;
|
|
93
|
+
size: z.ZodNumber;
|
|
94
|
+
mode: z.ZodEnum<{
|
|
95
|
+
100644: "100644";
|
|
96
|
+
100755: "100755";
|
|
97
|
+
}>;
|
|
98
|
+
}, z.core.$strict>>;
|
|
99
|
+
contentHash: z.ZodString;
|
|
100
|
+
}, z.core.$strict>;
|
|
101
|
+
treeHash: z.ZodString;
|
|
102
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
103
|
+
error: z.ZodLiteral<"starter_template_unavailable">;
|
|
104
|
+
}, z.core.$strict>]>>;
|
|
85
105
|
publication: z.ZodOptional<z.ZodObject<{
|
|
86
106
|
binding: z.ZodUnion<readonly [z.ZodObject<{
|
|
87
107
|
workspaceId: z.ZodString;
|
|
@@ -379,6 +399,21 @@ export declare const batchRunViewSchema: z.ZodObject<{
|
|
|
379
399
|
startedAt: z.ZodOptional<z.ZodString>;
|
|
380
400
|
finishedAt: z.ZodOptional<z.ZodString>;
|
|
381
401
|
queuePosition: z.ZodOptional<z.ZodNumber>;
|
|
402
|
+
waitingReason: z.ZodOptional<z.ZodEnum<{
|
|
403
|
+
session_busy: "session_busy";
|
|
404
|
+
directory_busy: "directory_busy";
|
|
405
|
+
directory_barrier: "directory_barrier";
|
|
406
|
+
workspace_limit: "workspace_limit";
|
|
407
|
+
sandbox_limit: "sandbox_limit";
|
|
408
|
+
interactive_reserve: "interactive_reserve";
|
|
409
|
+
interactive_reserve_configuration: "interactive_reserve_configuration";
|
|
410
|
+
batch_limit: "batch_limit";
|
|
411
|
+
session_limit: "session_limit";
|
|
412
|
+
build_limit: "build_limit";
|
|
413
|
+
source_freeze: "source_freeze";
|
|
414
|
+
migration_required: "migration_required";
|
|
415
|
+
batch_parent_unavailable: "batch_parent_unavailable";
|
|
416
|
+
}>>;
|
|
382
417
|
}, z.core.$strict>;
|
|
383
418
|
export type BatchRunView = z.infer<typeof batchRunViewSchema>;
|
|
384
419
|
/** `POST /internal/batch-runs/:runId/sync` — replace input of a not-yet-started Run. */
|
|
@@ -448,6 +483,21 @@ export declare const replaceBatchRunSnapshotResultSchema: z.ZodDiscriminatedUnio
|
|
|
448
483
|
startedAt: z.ZodOptional<z.ZodString>;
|
|
449
484
|
finishedAt: z.ZodOptional<z.ZodString>;
|
|
450
485
|
queuePosition: z.ZodOptional<z.ZodNumber>;
|
|
486
|
+
waitingReason: z.ZodOptional<z.ZodEnum<{
|
|
487
|
+
session_busy: "session_busy";
|
|
488
|
+
directory_busy: "directory_busy";
|
|
489
|
+
directory_barrier: "directory_barrier";
|
|
490
|
+
workspace_limit: "workspace_limit";
|
|
491
|
+
sandbox_limit: "sandbox_limit";
|
|
492
|
+
interactive_reserve: "interactive_reserve";
|
|
493
|
+
interactive_reserve_configuration: "interactive_reserve_configuration";
|
|
494
|
+
batch_limit: "batch_limit";
|
|
495
|
+
session_limit: "session_limit";
|
|
496
|
+
build_limit: "build_limit";
|
|
497
|
+
source_freeze: "source_freeze";
|
|
498
|
+
migration_required: "migration_required";
|
|
499
|
+
batch_parent_unavailable: "batch_parent_unavailable";
|
|
500
|
+
}>>;
|
|
451
501
|
}, z.core.$strict>;
|
|
452
502
|
}, z.core.$strict>, z.ZodObject<{
|
|
453
503
|
status: z.ZodLiteral<"pending_sync">;
|
|
@@ -553,6 +603,21 @@ export declare const batchRunEventSchema: z.ZodUnion<readonly [z.ZodObject<{
|
|
|
553
603
|
startedAt: z.ZodOptional<z.ZodString>;
|
|
554
604
|
finishedAt: z.ZodOptional<z.ZodString>;
|
|
555
605
|
queuePosition: z.ZodOptional<z.ZodNumber>;
|
|
606
|
+
waitingReason: z.ZodOptional<z.ZodEnum<{
|
|
607
|
+
session_busy: "session_busy";
|
|
608
|
+
directory_busy: "directory_busy";
|
|
609
|
+
directory_barrier: "directory_barrier";
|
|
610
|
+
workspace_limit: "workspace_limit";
|
|
611
|
+
sandbox_limit: "sandbox_limit";
|
|
612
|
+
interactive_reserve: "interactive_reserve";
|
|
613
|
+
interactive_reserve_configuration: "interactive_reserve_configuration";
|
|
614
|
+
batch_limit: "batch_limit";
|
|
615
|
+
session_limit: "session_limit";
|
|
616
|
+
build_limit: "build_limit";
|
|
617
|
+
source_freeze: "source_freeze";
|
|
618
|
+
migration_required: "migration_required";
|
|
619
|
+
batch_parent_unavailable: "batch_parent_unavailable";
|
|
620
|
+
}>>;
|
|
556
621
|
}, z.core.$strict>;
|
|
557
622
|
reason: z.ZodEnum<{
|
|
558
623
|
source_lost: "source_lost";
|
|
@@ -647,6 +712,21 @@ export declare const batchMemberViewSchema: z.ZodObject<{
|
|
|
647
712
|
delivering: "delivering";
|
|
648
713
|
}>;
|
|
649
714
|
queuePosition: z.ZodOptional<z.ZodNumber>;
|
|
715
|
+
waitingReason: z.ZodOptional<z.ZodEnum<{
|
|
716
|
+
session_busy: "session_busy";
|
|
717
|
+
directory_busy: "directory_busy";
|
|
718
|
+
directory_barrier: "directory_barrier";
|
|
719
|
+
workspace_limit: "workspace_limit";
|
|
720
|
+
sandbox_limit: "sandbox_limit";
|
|
721
|
+
interactive_reserve: "interactive_reserve";
|
|
722
|
+
interactive_reserve_configuration: "interactive_reserve_configuration";
|
|
723
|
+
batch_limit: "batch_limit";
|
|
724
|
+
session_limit: "session_limit";
|
|
725
|
+
build_limit: "build_limit";
|
|
726
|
+
source_freeze: "source_freeze";
|
|
727
|
+
migration_required: "migration_required";
|
|
728
|
+
batch_parent_unavailable: "batch_parent_unavailable";
|
|
729
|
+
}>>;
|
|
650
730
|
startedAt: z.ZodOptional<z.ZodString>;
|
|
651
731
|
finishedAt: z.ZodOptional<z.ZodString>;
|
|
652
732
|
directoryName: z.ZodOptional<z.ZodString>;
|
|
@@ -715,6 +795,21 @@ export declare const batchViewSchema: z.ZodObject<{
|
|
|
715
795
|
delivering: "delivering";
|
|
716
796
|
}>;
|
|
717
797
|
queuePosition: z.ZodOptional<z.ZodNumber>;
|
|
798
|
+
waitingReason: z.ZodOptional<z.ZodEnum<{
|
|
799
|
+
session_busy: "session_busy";
|
|
800
|
+
directory_busy: "directory_busy";
|
|
801
|
+
directory_barrier: "directory_barrier";
|
|
802
|
+
workspace_limit: "workspace_limit";
|
|
803
|
+
sandbox_limit: "sandbox_limit";
|
|
804
|
+
interactive_reserve: "interactive_reserve";
|
|
805
|
+
interactive_reserve_configuration: "interactive_reserve_configuration";
|
|
806
|
+
batch_limit: "batch_limit";
|
|
807
|
+
session_limit: "session_limit";
|
|
808
|
+
build_limit: "build_limit";
|
|
809
|
+
source_freeze: "source_freeze";
|
|
810
|
+
migration_required: "migration_required";
|
|
811
|
+
batch_parent_unavailable: "batch_parent_unavailable";
|
|
812
|
+
}>>;
|
|
718
813
|
startedAt: z.ZodOptional<z.ZodString>;
|
|
719
814
|
finishedAt: z.ZodOptional<z.ZodString>;
|
|
720
815
|
directoryName: z.ZodOptional<z.ZodString>;
|
|
@@ -796,6 +891,21 @@ export declare const batchCreateAcceptedSchema: z.ZodObject<{
|
|
|
796
891
|
delivering: "delivering";
|
|
797
892
|
}>;
|
|
798
893
|
queuePosition: z.ZodOptional<z.ZodNumber>;
|
|
894
|
+
waitingReason: z.ZodOptional<z.ZodEnum<{
|
|
895
|
+
session_busy: "session_busy";
|
|
896
|
+
directory_busy: "directory_busy";
|
|
897
|
+
directory_barrier: "directory_barrier";
|
|
898
|
+
workspace_limit: "workspace_limit";
|
|
899
|
+
sandbox_limit: "sandbox_limit";
|
|
900
|
+
interactive_reserve: "interactive_reserve";
|
|
901
|
+
interactive_reserve_configuration: "interactive_reserve_configuration";
|
|
902
|
+
batch_limit: "batch_limit";
|
|
903
|
+
session_limit: "session_limit";
|
|
904
|
+
build_limit: "build_limit";
|
|
905
|
+
source_freeze: "source_freeze";
|
|
906
|
+
migration_required: "migration_required";
|
|
907
|
+
batch_parent_unavailable: "batch_parent_unavailable";
|
|
908
|
+
}>>;
|
|
799
909
|
startedAt: z.ZodOptional<z.ZodString>;
|
|
800
910
|
finishedAt: z.ZodOptional<z.ZodString>;
|
|
801
911
|
directoryName: z.ZodOptional<z.ZodString>;
|
|
@@ -855,6 +965,14 @@ export declare const executionQueueEntrySchema: z.ZodObject<{
|
|
|
855
965
|
directory_barrier: "directory_barrier";
|
|
856
966
|
workspace_limit: "workspace_limit";
|
|
857
967
|
sandbox_limit: "sandbox_limit";
|
|
968
|
+
interactive_reserve: "interactive_reserve";
|
|
969
|
+
interactive_reserve_configuration: "interactive_reserve_configuration";
|
|
970
|
+
batch_limit: "batch_limit";
|
|
971
|
+
session_limit: "session_limit";
|
|
972
|
+
build_limit: "build_limit";
|
|
973
|
+
source_freeze: "source_freeze";
|
|
974
|
+
migration_required: "migration_required";
|
|
975
|
+
batch_parent_unavailable: "batch_parent_unavailable";
|
|
858
976
|
}>>;
|
|
859
977
|
}, z.core.$strict>;
|
|
860
978
|
export type ExecutionQueueEntry = z.infer<typeof executionQueueEntrySchema>;
|
|
@@ -899,6 +1017,14 @@ export declare const executionQueueViewSchema: z.ZodObject<{
|
|
|
899
1017
|
directory_barrier: "directory_barrier";
|
|
900
1018
|
workspace_limit: "workspace_limit";
|
|
901
1019
|
sandbox_limit: "sandbox_limit";
|
|
1020
|
+
interactive_reserve: "interactive_reserve";
|
|
1021
|
+
interactive_reserve_configuration: "interactive_reserve_configuration";
|
|
1022
|
+
batch_limit: "batch_limit";
|
|
1023
|
+
session_limit: "session_limit";
|
|
1024
|
+
build_limit: "build_limit";
|
|
1025
|
+
source_freeze: "source_freeze";
|
|
1026
|
+
migration_required: "migration_required";
|
|
1027
|
+
batch_parent_unavailable: "batch_parent_unavailable";
|
|
902
1028
|
}>>;
|
|
903
1029
|
}, z.core.$strict>>;
|
|
904
1030
|
}, z.core.$strict>;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"batch-runs.d.ts","sourceRoot":"","sources":["../../../src/cloud-workspace/runtime/batch-runs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;
|
|
1
|
+
{"version":3,"file":"batch-runs.d.ts","sourceRoot":"","sources":["../../../src/cloud-workspace/runtime/batch-runs.ts"],"names":[],"mappings":"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"}
|
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
import { z } from 'zod';
|
|
2
|
-
import { workspaceDirectoryNameSchema, workspaceSessionScopeSchema } from './workspace-directories.js';
|
|
2
|
+
import { workspaceDirectoryNameSchema, workspaceSessionScopeSchema, } from './workspace-directories.js';
|
|
3
3
|
import { batchSourceFailureSchema } from './batch-source.js';
|
|
4
4
|
import { workspacePreparationSchema, workspaceRegistrationSchema } from './workspace-binding.js';
|
|
5
|
-
import { WORKSPACE_REMIX_REFERENCE_MAX_COUNT, workspaceContextRemixReferenceSchema } from './remix-references.js';
|
|
5
|
+
import { WORKSPACE_REMIX_REFERENCE_MAX_COUNT, workspaceContextRemixReferenceSchema, workspaceStarterTemplateSnapshotSchema, } from './remix-references.js';
|
|
6
6
|
import { batchRunDeliveryEvidenceSchema, batchRunInstallationSchema, batchRunPhaseSchema, batchRunSchema, batchSourceSnapshotRefSchema, directoryAccessModeSchema, executionQueueHolderSchema, executionWaitingReasonSchema, } from './execution-admission.js';
|
|
7
7
|
/**
|
|
8
8
|
* Cross-service protocol of the batch flow (design §2, §5, §8, §9).
|
|
@@ -12,7 +12,8 @@ import { batchRunDeliveryEvidenceSchema, batchRunInstallationSchema, batchRunPha
|
|
|
12
12
|
const uuid = z.string().uuid();
|
|
13
13
|
const commitHash = z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/);
|
|
14
14
|
/* ---------------- Source freeze ---------------- */
|
|
15
|
-
export const batchSourceFreezeRequestSchema = z
|
|
15
|
+
export const batchSourceFreezeRequestSchema = z
|
|
16
|
+
.object({
|
|
16
17
|
batchId: uuid,
|
|
17
18
|
workspaceId: uuid,
|
|
18
19
|
sourceDirectoryName: workspaceDirectoryNameSchema,
|
|
@@ -21,26 +22,45 @@ export const batchSourceFreezeRequestSchema = z.object({
|
|
|
21
22
|
initiatorOperationId: z.string().min(1).max(128).optional(),
|
|
22
23
|
/** Optional idempotency key for sync-to-batch re-freeze (distinct from batchId). */
|
|
23
24
|
syncId: uuid.optional(),
|
|
24
|
-
})
|
|
25
|
+
})
|
|
26
|
+
.strict();
|
|
25
27
|
/**
|
|
26
28
|
* `frozen`: snapshot captured and durable.
|
|
27
29
|
* `pending`: source directory busy with another turn — freeze runs after that turn and before the next.
|
|
28
30
|
*/
|
|
29
|
-
export const batchSourceFreezeResultSchema = z
|
|
31
|
+
export const batchSourceFreezeResultSchema = z
|
|
32
|
+
.discriminatedUnion('status', [
|
|
30
33
|
z.object({ status: z.literal('frozen'), snapshot: batchSourceSnapshotRefSchema }).strict(),
|
|
31
|
-
z
|
|
32
|
-
|
|
33
|
-
|
|
34
|
+
z
|
|
35
|
+
.object({
|
|
36
|
+
status: z.literal('pending'),
|
|
37
|
+
batchId: uuid,
|
|
38
|
+
failure: batchSourceFailureSchema.optional(),
|
|
39
|
+
})
|
|
40
|
+
.strict(),
|
|
41
|
+
z
|
|
42
|
+
.object({
|
|
43
|
+
status: z.literal('failed'),
|
|
44
|
+
batchId: uuid,
|
|
45
|
+
error: z.string().max(128),
|
|
46
|
+
failure: batchSourceFailureSchema.optional(),
|
|
47
|
+
})
|
|
48
|
+
.strict(),
|
|
49
|
+
])
|
|
50
|
+
.refine((value) => value.status !== 'failed' || !value.failure || value.failure.code === value.error, { message: 'batch_source_failure_code_mismatch' });
|
|
34
51
|
/**
|
|
35
52
|
* `POST /internal/batch-runs/batch-created` — Business accepted a batch and asks Runtime to
|
|
36
53
|
* publish the `batch.created` workspace event that opens the panel in the browser.
|
|
37
54
|
*/
|
|
38
|
-
export const batchCreatedNotificationSchema = z
|
|
55
|
+
export const batchCreatedNotificationSchema = z
|
|
56
|
+
.object({
|
|
39
57
|
batchId: uuid,
|
|
40
58
|
workspaceId: uuid,
|
|
41
|
-
})
|
|
59
|
+
})
|
|
60
|
+
.strict();
|
|
42
61
|
/** Sandbox `POST /runtime/batch-sources/freeze`. Synchronous; idempotent per batchId. */
|
|
43
|
-
export const sandboxBatchSourceFreezeRequestSchema = z
|
|
62
|
+
export const sandboxBatchSourceFreezeRequestSchema = z
|
|
63
|
+
.object({
|
|
44
64
|
batchId: uuid,
|
|
45
65
|
workspaceId: uuid,
|
|
46
66
|
sourceDirectoryName: workspaceDirectoryNameSchema,
|
|
@@ -50,13 +70,40 @@ export const sandboxBatchSourceFreezeRequestSchema = z.object({
|
|
|
50
70
|
resumeOnly: z.boolean().optional(),
|
|
51
71
|
/** The existing host deadline also bounds a pending directory-access claim. */
|
|
52
72
|
deadline: z.string().datetime().optional(),
|
|
73
|
+
/** Trusted starting project for empty production sources; never used for ordinary turns. */
|
|
74
|
+
starterTemplate: z
|
|
75
|
+
.union([
|
|
76
|
+
z
|
|
77
|
+
.object({
|
|
78
|
+
snapshot: workspaceStarterTemplateSnapshotSchema,
|
|
79
|
+
treeHash: z.string().regex(/^[a-f0-9]{64}$/),
|
|
80
|
+
})
|
|
81
|
+
.strict(),
|
|
82
|
+
z.object({ error: z.literal('starter_template_unavailable') }).strict(),
|
|
83
|
+
])
|
|
84
|
+
.optional(),
|
|
53
85
|
/** Trusted Runtime identity and ephemeral access for publishing without changing the source checkout. */
|
|
54
|
-
publication: z
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
86
|
+
publication: z
|
|
87
|
+
.object({
|
|
88
|
+
binding: workspaceRegistrationSchema,
|
|
89
|
+
preparation: workspacePreparationSchema,
|
|
90
|
+
identity: z
|
|
91
|
+
.object({
|
|
92
|
+
runtimeId: z.string().min(1).max(128),
|
|
93
|
+
generation: z.number().int().nonnegative(),
|
|
94
|
+
runtimeEpoch: z.number().int().nonnegative(),
|
|
95
|
+
})
|
|
96
|
+
.strict(),
|
|
97
|
+
})
|
|
98
|
+
.strict()
|
|
99
|
+
.optional(),
|
|
100
|
+
})
|
|
101
|
+
.strict()
|
|
102
|
+
.refine((value) => !value.publication ||
|
|
103
|
+
(value.persist === 'remote_ref' &&
|
|
104
|
+
value.publication.binding.workspaceId === value.workspaceId &&
|
|
105
|
+
value.publication.binding.targetKind !== 'standalone' &&
|
|
106
|
+
value.publication.preparation.mode === 'clone'), { message: 'invalid_batch_source_publication' });
|
|
60
107
|
/* ---------------- Member execution (Runtime → sandbox) ---------------- */
|
|
61
108
|
const memberCommandBase = {
|
|
62
109
|
runId: uuid,
|
|
@@ -66,37 +113,56 @@ const memberCommandBase = {
|
|
|
66
113
|
/** Runtime-issued occupancy reference; the sandbox rejects member commands without it. */
|
|
67
114
|
occupancyId: uuid,
|
|
68
115
|
};
|
|
69
|
-
const batchRemixReferences = z
|
|
116
|
+
const batchRemixReferences = z
|
|
117
|
+
.array(workspaceContextRemixReferenceSchema)
|
|
118
|
+
.max(WORKSPACE_REMIX_REFERENCE_MAX_COUNT)
|
|
119
|
+
.optional();
|
|
70
120
|
/** `POST /runtime/batch-members/prepare` — clone/restore from snapshot (or resume commit), install deps. */
|
|
71
|
-
export const sandboxBatchMemberPrepareSchema = z
|
|
121
|
+
export const sandboxBatchMemberPrepareSchema = z
|
|
122
|
+
.object({
|
|
72
123
|
...memberCommandBase,
|
|
73
124
|
snapshot: batchSourceSnapshotRefSchema,
|
|
74
125
|
remixId: uuid.nullable(),
|
|
75
126
|
branchName: z.string().trim().min(1).max(512),
|
|
76
127
|
resumeFromCommit: commitHash.optional(),
|
|
77
128
|
remixReferences: batchRemixReferences,
|
|
78
|
-
})
|
|
129
|
+
})
|
|
130
|
+
.strict();
|
|
79
131
|
/** `POST /runtime/batch-members/generate` — one unattended turn on the shared session base. */
|
|
80
|
-
export const sandboxBatchMemberGenerateSchema = z
|
|
132
|
+
export const sandboxBatchMemberGenerateSchema = z
|
|
133
|
+
.object({
|
|
81
134
|
...memberCommandBase,
|
|
82
135
|
prompt: z.string().min(1).max(20_000),
|
|
83
136
|
model: z.string().min(1).max(200).optional(),
|
|
84
137
|
sessionId: z.string().min(1).max(128).optional(),
|
|
85
138
|
remixReferences: batchRemixReferences,
|
|
86
|
-
})
|
|
139
|
+
})
|
|
140
|
+
.strict();
|
|
87
141
|
/** `POST /runtime/batch-members/deliver` — save exact commit, push, build from it, verify, publish. */
|
|
88
|
-
export const sandboxBatchMemberDeliverSchema = z
|
|
142
|
+
export const sandboxBatchMemberDeliverSchema = z
|
|
143
|
+
.object({
|
|
89
144
|
...memberCommandBase,
|
|
90
145
|
pushRemote: z.boolean(),
|
|
91
146
|
fromCommit: commitHash.optional(),
|
|
92
|
-
})
|
|
147
|
+
})
|
|
148
|
+
.strict();
|
|
93
149
|
/** `POST /runtime/batch-members/:runId/stop`. */
|
|
94
|
-
export const sandboxBatchMemberStopSchema = z
|
|
150
|
+
export const sandboxBatchMemberStopSchema = z
|
|
151
|
+
.object({ runId: uuid, ownerFence: z.number().int().min(0) })
|
|
152
|
+
.strict();
|
|
95
153
|
export const sandboxBatchMemberStateSchema = z.enum([
|
|
96
|
-
'idle',
|
|
154
|
+
'idle',
|
|
155
|
+
'running',
|
|
156
|
+
'completed',
|
|
157
|
+
'failed',
|
|
158
|
+
'needs_user',
|
|
159
|
+
'stopping',
|
|
160
|
+
'stopped',
|
|
161
|
+
'unknown',
|
|
97
162
|
]);
|
|
98
163
|
/** Response of every member command and of `GET /runtime/batch-members/:runId`. Read-only query. */
|
|
99
|
-
export const sandboxBatchMemberStatusSchema = z
|
|
164
|
+
export const sandboxBatchMemberStatusSchema = z
|
|
165
|
+
.object({
|
|
100
166
|
runId: uuid,
|
|
101
167
|
ownerFence: z.number().int().min(0),
|
|
102
168
|
phase: batchRunPhaseSchema,
|
|
@@ -109,9 +175,11 @@ export const sandboxBatchMemberStatusSchema = z.object({
|
|
|
109
175
|
evidence: batchRunDeliveryEvidenceSchema.optional(),
|
|
110
176
|
error: z.string().max(128).optional(),
|
|
111
177
|
updatedAt: z.string().datetime(),
|
|
112
|
-
})
|
|
178
|
+
})
|
|
179
|
+
.strict();
|
|
113
180
|
/* ---------------- Runs (Business → Runtime) ---------------- */
|
|
114
|
-
export const batchRunMemberInputSchema = z
|
|
181
|
+
export const batchRunMemberInputSchema = z
|
|
182
|
+
.object({
|
|
115
183
|
resultVersionId: uuid,
|
|
116
184
|
workspaceId: uuid,
|
|
117
185
|
directoryName: workspaceDirectoryNameSchema,
|
|
@@ -124,19 +192,25 @@ export const batchRunMemberInputSchema = z.object({
|
|
|
124
192
|
resumeFromCommit: commitHash.optional(),
|
|
125
193
|
/** Prior result version this sync run replaces in the product sense (old version stays readable). */
|
|
126
194
|
syncOfResultVersionId: uuid.optional(),
|
|
127
|
-
})
|
|
195
|
+
})
|
|
196
|
+
.strict();
|
|
128
197
|
/** `POST /internal/batch-runs` — idempotent per resultVersionId. */
|
|
129
|
-
export const submitBatchRunsRequestSchema = z
|
|
198
|
+
export const submitBatchRunsRequestSchema = z
|
|
199
|
+
.object({
|
|
130
200
|
batchId: uuid,
|
|
131
201
|
userId: z.string().min(1).max(128),
|
|
132
202
|
snapshot: batchSourceSnapshotRefSchema,
|
|
133
203
|
members: z.array(batchRunMemberInputSchema).min(1).max(50),
|
|
134
|
-
})
|
|
204
|
+
})
|
|
205
|
+
.strict();
|
|
135
206
|
export const batchRunViewSchema = batchRunSchema.extend({
|
|
136
207
|
queuePosition: z.number().int().min(0).optional(),
|
|
208
|
+
waitingReason: executionWaitingReasonSchema.optional(),
|
|
137
209
|
});
|
|
138
210
|
/** `POST /internal/batch-runs/:runId/sync` — replace input of a not-yet-started Run. */
|
|
139
|
-
export const replaceBatchRunSnapshotSchema = z
|
|
211
|
+
export const replaceBatchRunSnapshotSchema = z
|
|
212
|
+
.object({ snapshot: batchSourceSnapshotRefSchema })
|
|
213
|
+
.strict();
|
|
140
214
|
/**
|
|
141
215
|
* Running, stopping, or reconciling members cannot switch snapshot mid-execution.
|
|
142
216
|
* The caller stores `pending_sync` and applies it after the Run ends.
|
|
@@ -146,16 +220,24 @@ export const replaceBatchRunSnapshotResultSchema = z.discriminatedUnion('status'
|
|
|
146
220
|
z.object({ status: z.literal('pending_sync'), runId: uuid }).strict(),
|
|
147
221
|
]);
|
|
148
222
|
/** Batch-level source fact. Present when the event is not about a member Run. */
|
|
149
|
-
export const batchSourceEventSubjectSchema = z
|
|
223
|
+
export const batchSourceEventSubjectSchema = z
|
|
224
|
+
.object({
|
|
150
225
|
batchId: uuid,
|
|
151
226
|
workspaceId: uuid,
|
|
152
227
|
status: z.enum(['ready', 'failed', 'lost']),
|
|
153
228
|
snapshot: batchSourceSnapshotRefSchema.optional(),
|
|
154
229
|
error: z.string().max(128).optional(),
|
|
155
230
|
failure: batchSourceFailureSchema.optional(),
|
|
156
|
-
})
|
|
231
|
+
})
|
|
232
|
+
.strict();
|
|
157
233
|
export const batchRunEventReasonSchema = z.enum([
|
|
158
|
-
'status_changed',
|
|
234
|
+
'status_changed',
|
|
235
|
+
'phase_changed',
|
|
236
|
+
'queue_changed',
|
|
237
|
+
'recovered',
|
|
238
|
+
'source_lost',
|
|
239
|
+
'source_ready',
|
|
240
|
+
'source_failed',
|
|
159
241
|
]);
|
|
160
242
|
/**
|
|
161
243
|
* Runtime → Business `POST /api/internal/cloud-batches/runs/events`; at-least-once, ordered by revision.
|
|
@@ -164,23 +246,43 @@ export const batchRunEventReasonSchema = z.enum([
|
|
|
164
246
|
*/
|
|
165
247
|
export const batchRunEventSchema = z.union([
|
|
166
248
|
z.object({ run: batchRunViewSchema, reason: batchRunEventReasonSchema }).strict(),
|
|
167
|
-
z
|
|
249
|
+
z
|
|
250
|
+
.object({
|
|
168
251
|
source: batchSourceEventSubjectSchema,
|
|
169
252
|
reason: z.enum(['source_ready', 'source_failed', 'source_lost']),
|
|
170
|
-
})
|
|
253
|
+
})
|
|
254
|
+
.strict(),
|
|
171
255
|
]);
|
|
172
256
|
/* ---------------- Projection for the panel (Business → frontend) ---------------- */
|
|
173
|
-
export const batchSourceStatusSchema = z.enum([
|
|
257
|
+
export const batchSourceStatusSchema = z.enum([
|
|
258
|
+
'freezing',
|
|
259
|
+
'waiting_source_idle',
|
|
260
|
+
'ready',
|
|
261
|
+
'failed',
|
|
262
|
+
'lost',
|
|
263
|
+
]);
|
|
174
264
|
export const batchMemberDisplayStatusSchema = z.enum([
|
|
175
|
-
'waiting_source',
|
|
176
|
-
'
|
|
265
|
+
'waiting_source',
|
|
266
|
+
'source_failed',
|
|
267
|
+
'queued',
|
|
268
|
+
'preparing',
|
|
269
|
+
'generating',
|
|
270
|
+
'delivering',
|
|
271
|
+
'reconciling',
|
|
272
|
+
'stopping',
|
|
273
|
+
'pending_sync',
|
|
274
|
+
'succeeded',
|
|
275
|
+
'failed',
|
|
276
|
+
'cancelled',
|
|
177
277
|
]);
|
|
178
|
-
export const batchMemberViewSchema = z
|
|
278
|
+
export const batchMemberViewSchema = z
|
|
279
|
+
.object({
|
|
179
280
|
resultVersionId: uuid,
|
|
180
281
|
ordinal: z.number().int().min(0),
|
|
181
282
|
prompt: z.string(),
|
|
182
283
|
status: batchMemberDisplayStatusSchema,
|
|
183
284
|
queuePosition: z.number().int().min(0).optional(),
|
|
285
|
+
waitingReason: executionWaitingReasonSchema.optional(),
|
|
184
286
|
startedAt: z.string().datetime().optional(),
|
|
185
287
|
finishedAt: z.string().datetime().optional(),
|
|
186
288
|
directoryName: workspaceDirectoryNameSchema.optional(),
|
|
@@ -191,47 +293,64 @@ export const batchMemberViewSchema = z.object({
|
|
|
191
293
|
previewStale: z.boolean().optional(),
|
|
192
294
|
error: z.string().max(128).optional(),
|
|
193
295
|
installation: batchRunInstallationSchema.optional(),
|
|
194
|
-
})
|
|
195
|
-
|
|
296
|
+
})
|
|
297
|
+
.strict();
|
|
298
|
+
export const batchViewSchema = z
|
|
299
|
+
.object({
|
|
196
300
|
batchId: uuid,
|
|
197
301
|
workspaceId: uuid,
|
|
198
302
|
sourceDirectoryName: workspaceDirectoryNameSchema,
|
|
199
303
|
sourceStatus: batchSourceStatusSchema,
|
|
200
304
|
sourceError: batchSourceFailureSchema.optional(),
|
|
201
305
|
cancelRequested: z.boolean(),
|
|
202
|
-
counts: z
|
|
306
|
+
counts: z
|
|
307
|
+
.object({
|
|
203
308
|
queued: z.number().int().min(0),
|
|
204
309
|
running: z.number().int().min(0),
|
|
205
310
|
succeeded: z.number().int().min(0),
|
|
206
311
|
failed: z.number().int().min(0),
|
|
207
312
|
cancelled: z.number().int().min(0),
|
|
208
|
-
})
|
|
313
|
+
})
|
|
314
|
+
.strict(),
|
|
209
315
|
members: z.array(batchMemberViewSchema),
|
|
210
316
|
createdAt: z.string().datetime(),
|
|
211
|
-
})
|
|
212
|
-
|
|
317
|
+
})
|
|
318
|
+
.strict();
|
|
319
|
+
export const batchCreateAcceptedSchema = z
|
|
320
|
+
.object({
|
|
213
321
|
flowVersion: z.literal('v2'),
|
|
214
322
|
accepted: z.literal(true),
|
|
215
323
|
batchId: uuid,
|
|
216
324
|
sourceStatus: batchSourceStatusSchema,
|
|
217
325
|
view: batchViewSchema,
|
|
218
|
-
})
|
|
326
|
+
})
|
|
327
|
+
.strict();
|
|
219
328
|
export function batchMemberDisplayStatus(run, source, pendingSync = false) {
|
|
220
329
|
if (!run)
|
|
221
330
|
return source === 'failed' || source === 'lost' ? 'source_failed' : 'waiting_source';
|
|
222
331
|
if (pendingSync && run.status !== 'queued')
|
|
223
332
|
return 'pending_sync';
|
|
224
333
|
switch (run.status) {
|
|
225
|
-
case 'queued':
|
|
226
|
-
|
|
227
|
-
case '
|
|
228
|
-
|
|
229
|
-
|
|
334
|
+
case 'queued':
|
|
335
|
+
return 'queued';
|
|
336
|
+
case 'running':
|
|
337
|
+
return run.phase === 'prepare'
|
|
338
|
+
? 'preparing'
|
|
339
|
+
: run.phase === 'generate'
|
|
340
|
+
? 'generating'
|
|
341
|
+
: 'delivering';
|
|
342
|
+
case 'reconciling':
|
|
343
|
+
return 'reconciling';
|
|
344
|
+
case 'stopping':
|
|
345
|
+
return 'stopping';
|
|
346
|
+
default:
|
|
347
|
+
return run.status;
|
|
230
348
|
}
|
|
231
349
|
}
|
|
232
350
|
/* ---------------- Queue view for chat (Runtime → frontend) ---------------- */
|
|
233
351
|
/** `GET /runtime/workspaces/:workspaceId/execution-queue` — open occupancies of the caller's sandbox. */
|
|
234
|
-
export const executionQueueEntrySchema = z
|
|
352
|
+
export const executionQueueEntrySchema = z
|
|
353
|
+
.object({
|
|
235
354
|
occupancyId: uuid,
|
|
236
355
|
workspaceId: uuid,
|
|
237
356
|
directoryName: workspaceSessionScopeSchema,
|
|
@@ -244,10 +363,13 @@ export const executionQueueEntrySchema = z.object({
|
|
|
244
363
|
accessMode: directoryAccessModeSchema.optional(),
|
|
245
364
|
holder: executionQueueHolderSchema.optional(),
|
|
246
365
|
waitingReason: executionWaitingReasonSchema.optional(),
|
|
247
|
-
})
|
|
248
|
-
|
|
366
|
+
})
|
|
367
|
+
.strict();
|
|
368
|
+
export const executionQueueViewSchema = z
|
|
369
|
+
.object({
|
|
249
370
|
workspaceMax: z.number().int().min(1),
|
|
250
371
|
sandboxMax: z.number().int().min(1),
|
|
251
372
|
entries: z.array(executionQueueEntrySchema),
|
|
252
|
-
})
|
|
373
|
+
})
|
|
374
|
+
.strict();
|
|
253
375
|
//# sourceMappingURL=batch-runs.js.map
|