@opengeni/worker-bundle 0.16.29 → 0.20.0
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/activities/agent-run-admission.d.ts +12 -0
- package/dist/activities/agent-turn.d.ts +110 -19
- package/dist/activities/api-integrations.d.ts +21 -0
- package/dist/activities/browser-state-artifact-reaper.d.ts +29 -0
- package/dist/activities/capabilities.d.ts +6 -0
- package/dist/activities/codemode-dispatcher.d.ts +35 -0
- package/dist/activities/codemode-token-renewal.d.ts +23 -0
- package/dist/activities/codex-capacity.d.ts +6 -5
- package/dist/activities/codex-image-generation.d.ts +21 -0
- package/dist/activities/context-compaction.d.ts +1 -0
- package/dist/activities/documents.d.ts +3 -2
- package/dist/activities/environment.d.ts +17 -8
- package/dist/activities/expiring-material-renewal.d.ts +1 -1
- package/dist/activities/file-upload-reaper.d.ts +7 -2
- package/dist/activities/gateway-image-generation.d.ts +39 -0
- package/dist/activities/gateway-video-generation.d.ts +53 -0
- package/dist/activities/generated-images.d.ts +112 -0
- package/dist/activities/git-credential-renewal.d.ts +1 -1
- package/dist/activities/goals.d.ts +2 -2
- package/dist/activities/google-drive-changes.d.ts +99 -0
- package/dist/activities/image-generation-operation.d.ts +74 -0
- package/dist/activities/image-generation-references.d.ts +25 -0
- package/dist/activities/knowledge-source-sync-driver.d.ts +23 -0
- package/dist/activities/knowledge-source-sync.d.ts +75 -0
- package/dist/activities/packs.d.ts +21 -36
- package/dist/activities/parent-wake.d.ts +1 -1
- package/dist/activities/retained-screenshot-reaper.d.ts +2 -2
- package/dist/activities/retained-screenshots.d.ts +36 -0
- package/dist/activities/rig-verification.d.ts +82 -5
- package/dist/activities/run-credential-renewal.d.ts +1 -1
- package/dist/activities/run-input.d.ts +3 -1
- package/dist/activities/sandbox-images.d.ts +14 -0
- package/dist/activities/sandbox-lease.d.ts +47 -9
- package/dist/activities/scheduled-tasks.d.ts +2 -2
- package/dist/activities/session-state.d.ts +7 -5
- package/dist/activities/site-auth-maintenance.d.ts +27 -0
- package/dist/activities/streaming.d.ts +1 -1
- package/dist/activities/types.d.ts +87 -5
- package/dist/activities/video-generation-admission.d.ts +43 -0
- package/dist/activities/video-generation-credential.d.ts +24 -0
- package/dist/activities/video-generation-reconciliation.d.ts +13 -0
- package/dist/activities/video-media-validation.d.ts +34 -0
- package/dist/activities/video-output-retention.d.ts +36 -0
- package/dist/activities/video-reference-staging.d.ts +55 -0
- package/dist/activities/workflow-wake.d.ts +2 -2
- package/dist/activities/workspace-capture.d.ts +10 -1
- package/dist/activities/xai-auth.d.ts +23 -0
- package/dist/activities/xai-image-generation.d.ts +26 -0
- package/dist/activities/xai-video-generation.d.ts +18 -0
- package/dist/activities-control-XURE4VKN.js +7221 -0
- package/dist/activities-control-XURE4VKN.js.map +1 -0
- package/dist/activities-control.d.ts +297 -0
- package/dist/activities-turn-6EBXGGLS.js +16036 -0
- package/dist/activities-turn-6EBXGGLS.js.map +1 -0
- package/dist/activities-turn.d.ts +17 -0
- package/dist/activities.d.ts +138 -150
- package/dist/activity-services.d.ts +10 -0
- package/dist/artifact-materializer-entry.d.ts +6 -0
- package/dist/artifact-materializer-entry.js +2662 -0
- package/dist/artifact-materializer-entry.js.map +1 -0
- package/dist/artifact-outbox-entry.d.ts +2 -0
- package/dist/artifact-outbox-entry.js +681 -0
- package/dist/artifact-outbox-entry.js.map +1 -0
- package/dist/chunk-5GRJIP5H.js +3092 -0
- package/dist/chunk-5GRJIP5H.js.map +1 -0
- package/dist/chunk-GRFQTTSQ.js +448 -0
- package/dist/chunk-GRFQTTSQ.js.map +1 -0
- package/dist/chunk-TYNPCG4U.js +906 -0
- package/dist/chunk-TYNPCG4U.js.map +1 -0
- package/dist/concurrency.d.ts +108 -5
- package/dist/editable-artifact-hint-broker.d.ts +49 -0
- package/dist/editable-artifact-materializer-launcher.d.ts +49 -0
- package/dist/editable-artifact-materializer-service.d.ts +108 -0
- package/dist/editable-artifact-materializer-storage.d.ts +12 -0
- package/dist/editable-artifact-materializer-subprocess.d.ts +50 -0
- package/dist/editable-artifact-materializer.d.ts +262 -0
- package/dist/editable-artifact-outbox-dispatcher.d.ts +44 -0
- package/dist/editable-artifact-outbox-service.d.ts +70 -0
- package/dist/host-export.d.ts +1 -1
- package/dist/index.d.ts +189 -10
- package/dist/index.js +715 -17380
- package/dist/index.js.map +1 -1
- package/dist/memory-pressure-guard.d.ts +57 -0
- package/dist/model-checkpoint-memory-collector.d.ts +23 -0
- package/dist/model-context-contributions.d.ts +40 -0
- package/dist/observability-metrics.d.ts +53 -1
- package/dist/sandbox-reaper-contract.d.ts +40 -0
- package/dist/sandbox-reaper-timeout.d.ts +14 -0
- package/dist/sandbox-resume.d.ts +34 -7
- package/dist/sandbox-routing.d.ts +6 -0
- package/dist/worker-service-lifecycle.d.ts +6 -2
- package/dist/workflow-bundle.js +1094 -370
- package/dist/workflows/activities.d.ts +8 -2
- package/dist/workflows/document-index.d.ts +1 -1
- package/dist/workflows/knowledge-source-sync.d.ts +13 -0
- package/dist/workflows/rig-verification.d.ts +1 -1
- package/dist/workflows/sandbox-reaper.d.ts +8 -0
- package/dist/workflows/scheduled-tasks.d.ts +1 -1
- package/dist/workflows/session.d.ts +2 -2
- package/dist/workflows/site-auth-maintenance.d.ts +2 -0
- package/dist/workflows/video-generation.d.ts +10 -0
- package/dist/workflows/workflow-wake.d.ts +1 -1
- package/dist/workflows.d.ts +10 -7
- package/package.json +35 -15
- package/src/activities/agent-run-admission.ts +76 -0
- package/src/activities/agent-turn.ts +2600 -340
- package/src/activities/api-integrations.ts +138 -0
- package/src/activities/browser-state-artifact-reaper.ts +120 -0
- package/src/activities/capabilities.ts +10 -0
- package/src/activities/codemode-dispatcher.ts +335 -0
- package/src/activities/codemode-token-renewal.ts +64 -0
- package/src/activities/codex-capacity.ts +54 -7
- package/src/activities/codex-image-generation.ts +56 -0
- package/src/activities/context-compaction.ts +38 -3
- package/src/activities/documents.ts +14 -4
- package/src/activities/environment.ts +54 -45
- package/src/activities/expiring-material-renewal.ts +1 -1
- package/src/activities/file-upload-reaper.ts +34 -3
- package/src/activities/gateway-image-generation.ts +146 -0
- package/src/activities/gateway-video-generation.ts +298 -0
- package/src/activities/generated-images.ts +860 -0
- package/src/activities/goals.ts +8 -3
- package/src/activities/google-drive-changes.ts +454 -0
- package/src/activities/image-generation-operation.ts +333 -0
- package/src/activities/image-generation-references.ts +118 -0
- package/src/activities/knowledge-source-sync-driver.ts +27 -0
- package/src/activities/knowledge-source-sync.ts +2840 -0
- package/src/activities/mcp-credentials.ts +1 -0
- package/src/activities/packs.ts +75 -152
- package/src/activities/parent-wake.ts +13 -1
- package/src/activities/retained-screenshot-reaper.ts +2 -2
- package/src/activities/retained-screenshots.ts +453 -28
- package/src/activities/rig-verification.ts +554 -43
- package/src/activities/run-input.ts +22 -6
- package/src/activities/sandbox-images.ts +167 -0
- package/src/activities/sandbox-lease.ts +1065 -483
- package/src/activities/scheduled-tasks.ts +104 -74
- package/src/activities/session-state.ts +22 -4
- package/src/activities/site-auth-maintenance.ts +269 -0
- package/src/activities/streaming.ts +42 -3
- package/src/activities/types.ts +104 -5
- package/src/activities/video-generation-admission.ts +303 -0
- package/src/activities/video-generation-credential.ts +112 -0
- package/src/activities/video-generation-reconciliation.ts +771 -0
- package/src/activities/video-media-validation.ts +332 -0
- package/src/activities/video-output-retention.ts +314 -0
- package/src/activities/video-reference-staging.ts +350 -0
- package/src/activities/workflow-wake.ts +2 -2
- package/src/activities/workspace-capture.ts +44 -10
- package/src/activities/xai-auth.ts +122 -0
- package/src/activities/xai-image-generation.ts +86 -0
- package/src/activities/xai-video-generation.ts +69 -0
- package/src/activities-control.ts +58 -0
- package/src/activities-turn.ts +40 -0
- package/src/activities.ts +53 -124
- package/src/activity-services.ts +62 -0
- package/src/artifact-materializer-entry.ts +35 -0
- package/src/artifact-outbox-entry.ts +29 -0
- package/src/concurrency.ts +484 -6
- package/src/editable-artifact-hint-broker.ts +235 -0
- package/src/editable-artifact-materializer-launcher.ts +515 -0
- package/src/editable-artifact-materializer-service.ts +787 -0
- package/src/editable-artifact-materializer-storage.ts +413 -0
- package/src/editable-artifact-materializer-subprocess.ts +956 -0
- package/src/editable-artifact-materializer.ts +1289 -0
- package/src/editable-artifact-outbox-dispatcher.ts +244 -0
- package/src/editable-artifact-outbox-service.ts +438 -0
- package/src/index.ts +328 -72
- package/src/memory-pressure-guard.ts +489 -0
- package/src/model-checkpoint-memory-collector.ts +123 -0
- package/src/model-context-contributions.ts +159 -0
- package/src/observability-metrics.ts +297 -13
- package/src/sandbox-reaper-contract.ts +73 -0
- package/src/sandbox-reaper-timeout.ts +79 -0
- package/src/sandbox-resume.ts +294 -153
- package/src/sandbox-routing.ts +32 -24
- package/src/worker-service-lifecycle.ts +80 -14
- package/src/workflows/activities.ts +31 -0
- package/src/workflows/file-upload-reaper.ts +9 -1
- package/src/workflows/knowledge-source-sync.ts +83 -0
- package/src/workflows/sandbox-reaper.ts +183 -21
- package/src/workflows/scheduled-tasks.ts +42 -6
- package/src/workflows/session.ts +20 -6
- package/src/workflows/site-auth-maintenance.ts +14 -0
- package/src/workflows/video-generation.ts +36 -0
- package/src/workflows.ts +18 -1
- package/dist/activities/toolspace-token-renewal.d.ts +0 -23
- package/src/activities/toolspace-token-renewal.ts +0 -64
|
@@ -0,0 +1,681 @@
|
|
|
1
|
+
// src/editable-artifact-outbox-service.ts
|
|
2
|
+
import {
|
|
3
|
+
dbSearchPath,
|
|
4
|
+
getSettings,
|
|
5
|
+
resolveNatsControlPlaneAuth
|
|
6
|
+
} from "@opengeni/config";
|
|
7
|
+
import { createObservability } from "@opengeni/observability";
|
|
8
|
+
|
|
9
|
+
// src/editable-artifact-outbox-dispatcher.ts
|
|
10
|
+
import {
|
|
11
|
+
EditableArtifactLiveOutboxDispatcher,
|
|
12
|
+
MathEditableArtifactOutboxRandom,
|
|
13
|
+
SystemEditableArtifactLiveClock,
|
|
14
|
+
SystemEditableArtifactLiveScheduler
|
|
15
|
+
} from "@opengeni/core";
|
|
16
|
+
import {
|
|
17
|
+
PostgresEditableArtifactStore,
|
|
18
|
+
createDb,
|
|
19
|
+
dbSql
|
|
20
|
+
} from "@opengeni/db";
|
|
21
|
+
|
|
22
|
+
// src/editable-artifact-hint-broker.ts
|
|
23
|
+
import {
|
|
24
|
+
EDITABLE_ARTIFACT_HINT_MAX_BYTES
|
|
25
|
+
} from "@opengeni/core";
|
|
26
|
+
import { connect } from "@opengeni/events";
|
|
27
|
+
var DEFAULT_CONNECTION_NAME = "opengeni-editable-artifact-outbox";
|
|
28
|
+
var ConfirmedNatsEditableArtifactHintBroker = class {
|
|
29
|
+
constructor(connection, options = {}) {
|
|
30
|
+
this.connection = connection;
|
|
31
|
+
this.maxHintBytes = options.maxHintBytes ?? EDITABLE_ARTIFACT_HINT_MAX_BYTES;
|
|
32
|
+
if (!Number.isSafeInteger(this.maxHintBytes) || this.maxHintBytes < 1 || this.maxHintBytes > EDITABLE_ARTIFACT_HINT_MAX_BYTES) {
|
|
33
|
+
throw new TypeError("Editable artifact NATS hint byte limit is invalid");
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
maxHintBytes;
|
|
37
|
+
async publish(input) {
|
|
38
|
+
assertSubject(input.subject);
|
|
39
|
+
if (!(input.payload instanceof Uint8Array) || input.payload.byteLength < 1 || input.payload.byteLength > this.maxHintBytes) {
|
|
40
|
+
throw new EditableArtifactNatsHintPublishError(
|
|
41
|
+
"broker_backpressure",
|
|
42
|
+
"Editable artifact hint exceeds the NATS envelope"
|
|
43
|
+
);
|
|
44
|
+
}
|
|
45
|
+
if (input.signal.aborted) throw abortedPublish();
|
|
46
|
+
if (this.connection.isClosed() || this.connection.isDraining()) {
|
|
47
|
+
throw new EditableArtifactNatsHintPublishError(
|
|
48
|
+
"broker_unavailable",
|
|
49
|
+
"Editable artifact NATS connection is closed"
|
|
50
|
+
);
|
|
51
|
+
}
|
|
52
|
+
try {
|
|
53
|
+
this.connection.publish(input.subject, input.payload);
|
|
54
|
+
await abortable(this.connection.flush(), input.signal);
|
|
55
|
+
} catch (error) {
|
|
56
|
+
if (input.signal.aborted) throw abortedPublish();
|
|
57
|
+
if (error instanceof EditableArtifactNatsHintPublishError) throw error;
|
|
58
|
+
throw new EditableArtifactNatsHintPublishError(
|
|
59
|
+
"broker_unavailable",
|
|
60
|
+
"Editable artifact NATS publish was not acknowledged",
|
|
61
|
+
{ cause: error }
|
|
62
|
+
);
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
/**
|
|
66
|
+
* A readiness probe must prove the server is reachable, not merely that the
|
|
67
|
+
* client object has not observed closure yet. `flush()` is a bounded NATS
|
|
68
|
+
* round trip and has the same acknowledgement semantics as publication.
|
|
69
|
+
*/
|
|
70
|
+
async check(signal = new AbortController().signal) {
|
|
71
|
+
if (signal.aborted) throw abortedPublish();
|
|
72
|
+
if (this.connection.isClosed() || this.connection.isDraining()) {
|
|
73
|
+
throw new EditableArtifactNatsHintPublishError(
|
|
74
|
+
"broker_unavailable",
|
|
75
|
+
"Editable artifact NATS connection is unavailable"
|
|
76
|
+
);
|
|
77
|
+
}
|
|
78
|
+
try {
|
|
79
|
+
await abortable(this.connection.flush(), signal);
|
|
80
|
+
} catch (error) {
|
|
81
|
+
if (error instanceof EditableArtifactNatsHintPublishError) throw error;
|
|
82
|
+
throw new EditableArtifactNatsHintPublishError(
|
|
83
|
+
"broker_unavailable",
|
|
84
|
+
"Editable artifact NATS readiness round trip failed",
|
|
85
|
+
{ cause: error }
|
|
86
|
+
);
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
async close(drainTimeoutMs = 5e3) {
|
|
90
|
+
if (!Number.isSafeInteger(drainTimeoutMs) || drainTimeoutMs < 1 || drainTimeoutMs > 3e4) {
|
|
91
|
+
throw new TypeError("Editable artifact NATS drain timeout is invalid");
|
|
92
|
+
}
|
|
93
|
+
if (this.connection.isClosed()) return;
|
|
94
|
+
if (this.connection.isDraining()) {
|
|
95
|
+
await this.connection.closed();
|
|
96
|
+
return;
|
|
97
|
+
}
|
|
98
|
+
let timer;
|
|
99
|
+
const drain = this.connection.drain();
|
|
100
|
+
const outcome = await Promise.race([
|
|
101
|
+
drain.then(
|
|
102
|
+
() => "drained",
|
|
103
|
+
() => "failed"
|
|
104
|
+
),
|
|
105
|
+
new Promise((resolve) => {
|
|
106
|
+
timer = setTimeout(() => resolve("timed_out"), drainTimeoutMs);
|
|
107
|
+
})
|
|
108
|
+
]);
|
|
109
|
+
if (timer) clearTimeout(timer);
|
|
110
|
+
if (outcome !== "drained" && !this.connection.isClosed()) {
|
|
111
|
+
await this.connection.close();
|
|
112
|
+
}
|
|
113
|
+
}
|
|
114
|
+
};
|
|
115
|
+
var EditableArtifactNatsHintPublishError = class extends Error {
|
|
116
|
+
constructor(code, message, options) {
|
|
117
|
+
super(message, options);
|
|
118
|
+
this.code = code;
|
|
119
|
+
this.name = "EditableArtifactNatsHintPublishError";
|
|
120
|
+
}
|
|
121
|
+
};
|
|
122
|
+
async function connectEditableArtifactHintBroker(input) {
|
|
123
|
+
const natsUrl = boundedText(input.natsUrl, "NATS URL", 2048);
|
|
124
|
+
const name = boundedText(input.name ?? DEFAULT_CONNECTION_NAME, "NATS connection name", 128);
|
|
125
|
+
const auth = natsAuthOptions(input.auth);
|
|
126
|
+
const connection = await connect({
|
|
127
|
+
servers: natsUrl,
|
|
128
|
+
name,
|
|
129
|
+
reconnect: true,
|
|
130
|
+
maxReconnectAttempts: -1,
|
|
131
|
+
reconnectTimeWait: 2e3,
|
|
132
|
+
reconnectJitter: 1e3,
|
|
133
|
+
reconnectJitterTLS: 1e3,
|
|
134
|
+
waitOnFirstConnect: true,
|
|
135
|
+
pingInterval: 2e4,
|
|
136
|
+
maxPingOut: 3,
|
|
137
|
+
...auth
|
|
138
|
+
});
|
|
139
|
+
return new ConfirmedNatsEditableArtifactHintBroker(connection, {
|
|
140
|
+
...input.maxHintBytes === void 0 ? {} : { maxHintBytes: input.maxHintBytes }
|
|
141
|
+
});
|
|
142
|
+
}
|
|
143
|
+
function natsAuthOptions(auth) {
|
|
144
|
+
if (auth.kind === "anonymous") return {};
|
|
145
|
+
if (auth.kind === "token") return { token: boundedText(auth.token, "NATS token", 4096) };
|
|
146
|
+
return {
|
|
147
|
+
user: boundedText(auth.user, "NATS user", 256),
|
|
148
|
+
pass: boundedText(auth.pass, "NATS password", 4096)
|
|
149
|
+
};
|
|
150
|
+
}
|
|
151
|
+
function assertSubject(subject) {
|
|
152
|
+
const bytes = new TextEncoder().encode(subject).byteLength;
|
|
153
|
+
if (bytes < 1 || bytes > 1024 || subject.startsWith(".") || subject.endsWith(".") || subject.includes("..") || /[\s*>]/u.test(subject)) {
|
|
154
|
+
throw new EditableArtifactNatsHintPublishError(
|
|
155
|
+
"broker_backpressure",
|
|
156
|
+
"Editable artifact NATS subject is malformed"
|
|
157
|
+
);
|
|
158
|
+
}
|
|
159
|
+
}
|
|
160
|
+
function boundedText(value, label, maxBytes) {
|
|
161
|
+
const bytes = new TextEncoder().encode(value).byteLength;
|
|
162
|
+
if (bytes < 1 || bytes > maxBytes || value.trim() !== value) {
|
|
163
|
+
throw new TypeError(`${label} is malformed`);
|
|
164
|
+
}
|
|
165
|
+
return value;
|
|
166
|
+
}
|
|
167
|
+
function abortedPublish() {
|
|
168
|
+
return new EditableArtifactNatsHintPublishError(
|
|
169
|
+
"broker_unavailable",
|
|
170
|
+
"Editable artifact NATS publish was aborted"
|
|
171
|
+
);
|
|
172
|
+
}
|
|
173
|
+
async function abortable(operation, signal) {
|
|
174
|
+
if (signal.aborted) throw abortedPublish();
|
|
175
|
+
let remove = () => void 0;
|
|
176
|
+
const aborted = new Promise((_resolve, reject) => {
|
|
177
|
+
const onAbort = () => reject(abortedPublish());
|
|
178
|
+
signal.addEventListener("abort", onAbort, { once: true });
|
|
179
|
+
remove = () => signal.removeEventListener("abort", onAbort);
|
|
180
|
+
});
|
|
181
|
+
try {
|
|
182
|
+
await Promise.race([operation, aborted]);
|
|
183
|
+
} finally {
|
|
184
|
+
remove();
|
|
185
|
+
}
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
// src/editable-artifact-outbox-dispatcher.ts
|
|
189
|
+
var EDITABLE_ARTIFACT_OUTBOX_DISPATCHER_DATABASE_ROLE = "opengeni_artifact_outbox_dispatcher";
|
|
190
|
+
var EDITABLE_ARTIFACT_OUTBOX_DATABASE_URL_ENV = "OPENGENI_ARTIFACT_OUTBOX_DATABASE_URL";
|
|
191
|
+
var EditableArtifactOutboxWorkerRuntime = class {
|
|
192
|
+
constructor(dispatcher, broker, database) {
|
|
193
|
+
this.dispatcher = dispatcher;
|
|
194
|
+
this.broker = broker;
|
|
195
|
+
this.database = database;
|
|
196
|
+
}
|
|
197
|
+
abort = new AbortController();
|
|
198
|
+
running = null;
|
|
199
|
+
closing = null;
|
|
200
|
+
start() {
|
|
201
|
+
if (this.closing) return Promise.reject(new Error("Artifact outbox worker is stopping"));
|
|
202
|
+
this.running ??= this.dispatcher.run(this.abort.signal);
|
|
203
|
+
return this.running;
|
|
204
|
+
}
|
|
205
|
+
drain() {
|
|
206
|
+
if (this.abort.signal.aborted) return false;
|
|
207
|
+
this.abort.abort();
|
|
208
|
+
return true;
|
|
209
|
+
}
|
|
210
|
+
async check(signal) {
|
|
211
|
+
if (this.abort.signal.aborted || this.closing) {
|
|
212
|
+
throw new Error("Artifact outbox worker is stopping");
|
|
213
|
+
}
|
|
214
|
+
await Promise.all([
|
|
215
|
+
assertDedicatedOutboxDispatcherDatabaseRole(this.database.db),
|
|
216
|
+
this.broker.check(signal)
|
|
217
|
+
]);
|
|
218
|
+
}
|
|
219
|
+
stop() {
|
|
220
|
+
if (this.closing) return this.closing;
|
|
221
|
+
this.closing = this.stopOnce();
|
|
222
|
+
return this.closing;
|
|
223
|
+
}
|
|
224
|
+
async stopOnce() {
|
|
225
|
+
this.drain();
|
|
226
|
+
const running = this.running ? await Promise.allSettled([this.running]) : [];
|
|
227
|
+
const cleanup = await Promise.allSettled([this.broker.close(), this.database.close()]);
|
|
228
|
+
const failure = [...running, ...cleanup].find(
|
|
229
|
+
(result) => result.status === "rejected"
|
|
230
|
+
);
|
|
231
|
+
if (failure) throw failure.reason;
|
|
232
|
+
}
|
|
233
|
+
};
|
|
234
|
+
async function createEditableArtifactOutboxWorker(options) {
|
|
235
|
+
const dispatcherDatabaseUrl = dedicatedDispatcherDatabaseUrl(options.dispatcherDatabaseUrl);
|
|
236
|
+
const databasePoolSize = options.databasePoolSize ?? 2;
|
|
237
|
+
if (!Number.isSafeInteger(databasePoolSize) || databasePoolSize < 1 || databasePoolSize > 8) {
|
|
238
|
+
throw new TypeError("Artifact outbox dispatcher DB pool size must be 1-8");
|
|
239
|
+
}
|
|
240
|
+
const database = createDb(dispatcherDatabaseUrl, {
|
|
241
|
+
max: databasePoolSize,
|
|
242
|
+
...options.databaseSearchPath ? { searchPath: options.databaseSearchPath } : {}
|
|
243
|
+
});
|
|
244
|
+
let broker;
|
|
245
|
+
try {
|
|
246
|
+
await assertDedicatedOutboxDispatcherDatabaseRole(database.db);
|
|
247
|
+
broker = await connectEditableArtifactHintBroker({
|
|
248
|
+
natsUrl: options.natsUrl,
|
|
249
|
+
auth: options.natsAuth
|
|
250
|
+
});
|
|
251
|
+
} catch (error) {
|
|
252
|
+
await database.close();
|
|
253
|
+
throw error;
|
|
254
|
+
}
|
|
255
|
+
const persistence = new PostgresEditableArtifactStore(database.db);
|
|
256
|
+
const store = dispatcherStore(persistence);
|
|
257
|
+
const dispatcher = new EditableArtifactLiveOutboxDispatcher(
|
|
258
|
+
{
|
|
259
|
+
store,
|
|
260
|
+
broker,
|
|
261
|
+
clock: new SystemEditableArtifactLiveClock(),
|
|
262
|
+
scheduler: new SystemEditableArtifactLiveScheduler(),
|
|
263
|
+
random: new MathEditableArtifactOutboxRandom(),
|
|
264
|
+
...options.metrics ? { metrics: options.metrics } : {},
|
|
265
|
+
...options.logger ? { logger: options.logger } : {}
|
|
266
|
+
},
|
|
267
|
+
{
|
|
268
|
+
owner: options.owner ?? `artifact-outbox:${crypto.randomUUID()}`,
|
|
269
|
+
...options.dispatcher
|
|
270
|
+
}
|
|
271
|
+
);
|
|
272
|
+
return new EditableArtifactOutboxWorkerRuntime(dispatcher, broker, database);
|
|
273
|
+
}
|
|
274
|
+
async function assertDedicatedOutboxDispatcherDatabaseRole(db) {
|
|
275
|
+
const raw = await db.execute(dbSql`
|
|
276
|
+
select
|
|
277
|
+
current_user::text as current_role,
|
|
278
|
+
session_user::text as session_role,
|
|
279
|
+
exists (
|
|
280
|
+
select 1
|
|
281
|
+
from pg_catalog.pg_class relation_row
|
|
282
|
+
join pg_catalog.pg_namespace namespace_row
|
|
283
|
+
on namespace_row.oid = relation_row.relnamespace
|
|
284
|
+
where namespace_row.nspname = current_schema()
|
|
285
|
+
and relation_row.relkind in ('r', 'p', 'v', 'm', 'f')
|
|
286
|
+
and (
|
|
287
|
+
has_table_privilege(current_user, relation_row.oid, 'SELECT')
|
|
288
|
+
or has_table_privilege(current_user, relation_row.oid, 'INSERT')
|
|
289
|
+
or has_table_privilege(current_user, relation_row.oid, 'UPDATE')
|
|
290
|
+
or has_table_privilege(current_user, relation_row.oid, 'DELETE')
|
|
291
|
+
or has_table_privilege(current_user, relation_row.oid, 'TRUNCATE')
|
|
292
|
+
or has_table_privilege(current_user, relation_row.oid, 'REFERENCES')
|
|
293
|
+
or has_table_privilege(current_user, relation_row.oid, 'TRIGGER')
|
|
294
|
+
or has_any_column_privilege(current_user, relation_row.oid, 'SELECT')
|
|
295
|
+
or has_any_column_privilege(current_user, relation_row.oid, 'INSERT')
|
|
296
|
+
or has_any_column_privilege(current_user, relation_row.oid, 'UPDATE')
|
|
297
|
+
or has_any_column_privilege(current_user, relation_row.oid, 'REFERENCES')
|
|
298
|
+
)
|
|
299
|
+
) as can_access_any_relation,
|
|
300
|
+
exists (
|
|
301
|
+
select 1
|
|
302
|
+
from pg_catalog.pg_class sequence_row
|
|
303
|
+
join pg_catalog.pg_namespace namespace_row
|
|
304
|
+
on namespace_row.oid = sequence_row.relnamespace
|
|
305
|
+
where namespace_row.nspname = current_schema()
|
|
306
|
+
and sequence_row.relkind = 'S'
|
|
307
|
+
and (
|
|
308
|
+
has_sequence_privilege(current_user, sequence_row.oid, 'USAGE')
|
|
309
|
+
or has_sequence_privilege(current_user, sequence_row.oid, 'SELECT')
|
|
310
|
+
or has_sequence_privilege(current_user, sequence_row.oid, 'UPDATE')
|
|
311
|
+
)
|
|
312
|
+
) as can_access_any_sequence
|
|
313
|
+
`);
|
|
314
|
+
const rows = Array.isArray(raw) ? raw : raw.rows ?? [];
|
|
315
|
+
const row = rows[0];
|
|
316
|
+
if (row?.current_role !== EDITABLE_ARTIFACT_OUTBOX_DISPATCHER_DATABASE_ROLE || row.session_role !== EDITABLE_ARTIFACT_OUTBOX_DISPATCHER_DATABASE_ROLE || row.can_access_any_relation !== false || row.can_access_any_sequence !== false) {
|
|
317
|
+
throw new Error("Artifact outbox dispatcher database connection has an unsafe role posture");
|
|
318
|
+
}
|
|
319
|
+
}
|
|
320
|
+
function dispatcherStore(persistence) {
|
|
321
|
+
return {
|
|
322
|
+
claimLiveOutbox: async (input) => await persistence.claimLiveOutbox(
|
|
323
|
+
input
|
|
324
|
+
),
|
|
325
|
+
renewLiveOutbox: async (input) => await persistence.renewLiveOutbox(input),
|
|
326
|
+
markLiveOutboxPublished: async (input) => await persistence.markLiveOutboxPublished(input),
|
|
327
|
+
retryLiveOutbox: async (input) => await persistence.retryLiveOutbox(input),
|
|
328
|
+
deadLetterLiveOutbox: async (input) => await persistence.deadLetterLiveOutbox(input)
|
|
329
|
+
};
|
|
330
|
+
}
|
|
331
|
+
function dedicatedDispatcherDatabaseUrl(raw) {
|
|
332
|
+
if (typeof raw !== "string" || raw.length > 8192 || raw.trim() !== raw) {
|
|
333
|
+
throw new TypeError(`${EDITABLE_ARTIFACT_OUTBOX_DATABASE_URL_ENV} is malformed`);
|
|
334
|
+
}
|
|
335
|
+
let url;
|
|
336
|
+
try {
|
|
337
|
+
url = new URL(raw);
|
|
338
|
+
} catch (cause) {
|
|
339
|
+
throw new TypeError(`${EDITABLE_ARTIFACT_OUTBOX_DATABASE_URL_ENV} is malformed`, { cause });
|
|
340
|
+
}
|
|
341
|
+
if (url.protocol !== "postgres:" && url.protocol !== "postgresql:" || decodeURIComponent(url.username) !== EDITABLE_ARTIFACT_OUTBOX_DISPATCHER_DATABASE_ROLE) {
|
|
342
|
+
throw new TypeError(
|
|
343
|
+
`${EDITABLE_ARTIFACT_OUTBOX_DATABASE_URL_ENV} must authenticate as ${EDITABLE_ARTIFACT_OUTBOX_DISPATCHER_DATABASE_ROLE}`
|
|
344
|
+
);
|
|
345
|
+
}
|
|
346
|
+
return raw;
|
|
347
|
+
}
|
|
348
|
+
|
|
349
|
+
// src/editable-artifact-outbox-service.ts
|
|
350
|
+
async function createProductionEditableArtifactOutboxService(options) {
|
|
351
|
+
if (options.declaredDatabaseRole !== EDITABLE_ARTIFACT_OUTBOX_DISPATCHER_DATABASE_ROLE) {
|
|
352
|
+
throw new Error("Artifact outbox dispatcher database role declaration is invalid");
|
|
353
|
+
}
|
|
354
|
+
const observability = createObservability(options.settings, {
|
|
355
|
+
component: "artifact-outbox-dispatcher"
|
|
356
|
+
});
|
|
357
|
+
const databaseSearchPath = dbSearchPath(options.settings);
|
|
358
|
+
const runtime = await createEditableArtifactOutboxWorker({
|
|
359
|
+
dispatcherDatabaseUrl: options.databaseUrl,
|
|
360
|
+
...databaseSearchPath ? { databaseSearchPath } : {},
|
|
361
|
+
...options.databasePoolSize === void 0 ? {} : { databasePoolSize: options.databasePoolSize },
|
|
362
|
+
natsUrl: options.natsUrl,
|
|
363
|
+
natsAuth: options.natsAuth,
|
|
364
|
+
owner: options.owner,
|
|
365
|
+
dispatcher: {
|
|
366
|
+
...options.batchSize === void 0 ? {} : { batchSize: options.batchSize },
|
|
367
|
+
...options.concurrency === void 0 ? {} : { concurrency: options.concurrency },
|
|
368
|
+
...options.leaseDurationMs === void 0 ? {} : { leaseDurationMs: options.leaseDurationMs },
|
|
369
|
+
...options.leaseRenewIntervalMs === void 0 ? {} : { leaseRenewIntervalMs: options.leaseRenewIntervalMs },
|
|
370
|
+
...options.pollIntervalMs === void 0 ? {} : { pollIntervalMs: options.pollIntervalMs },
|
|
371
|
+
...options.publishTimeoutMs === void 0 ? {} : { publishTimeoutMs: options.publishTimeoutMs },
|
|
372
|
+
...options.retryBaseMs === void 0 ? {} : { retryBaseMs: options.retryBaseMs },
|
|
373
|
+
...options.retryMaxMs === void 0 ? {} : { retryMaxMs: options.retryMaxMs }
|
|
374
|
+
},
|
|
375
|
+
metrics: {
|
|
376
|
+
increment(outcome, count = 1) {
|
|
377
|
+
observability.incrementCounter({
|
|
378
|
+
name: "opengeni_artifact_outbox_dispatch_total",
|
|
379
|
+
help: "Editable artifact outbox dispatch actions by closed outcome.",
|
|
380
|
+
labels: { outcome },
|
|
381
|
+
amount: count
|
|
382
|
+
});
|
|
383
|
+
},
|
|
384
|
+
observePublishSeconds(outcome, seconds) {
|
|
385
|
+
observability.observeHistogram({
|
|
386
|
+
name: "opengeni_artifact_outbox_publish_seconds",
|
|
387
|
+
help: "Editable artifact broker publication latency by closed outcome.",
|
|
388
|
+
labels: { outcome },
|
|
389
|
+
value: seconds
|
|
390
|
+
});
|
|
391
|
+
}
|
|
392
|
+
},
|
|
393
|
+
logger: {
|
|
394
|
+
warn(message, attributes) {
|
|
395
|
+
observability.warn(message, {
|
|
396
|
+
errorClass: "WorkerOperationError",
|
|
397
|
+
errorCode: "worker_operation_failed",
|
|
398
|
+
origin: "worker",
|
|
399
|
+
outcome: typeof attributes.code === "string" ? attributes.code : "unknown"
|
|
400
|
+
});
|
|
401
|
+
}
|
|
402
|
+
}
|
|
403
|
+
});
|
|
404
|
+
return createEditableArtifactOutboxService({
|
|
405
|
+
runtime,
|
|
406
|
+
observability,
|
|
407
|
+
serviceName: options.settings.serviceName,
|
|
408
|
+
environment: options.settings.environment,
|
|
409
|
+
deploymentRevision: options.settings.deploymentRevision
|
|
410
|
+
});
|
|
411
|
+
}
|
|
412
|
+
function createEditableArtifactOutboxService(input) {
|
|
413
|
+
let state = "starting";
|
|
414
|
+
let runPromise = null;
|
|
415
|
+
let closePromise = null;
|
|
416
|
+
let readinessPromise = null;
|
|
417
|
+
const readinessTimeoutMs = input.readinessTimeoutMs ?? 2e3;
|
|
418
|
+
const ready = () => {
|
|
419
|
+
if (readinessPromise) return readinessPromise;
|
|
420
|
+
const abort = new AbortController();
|
|
421
|
+
const check = withTimeout(input.runtime.check(abort.signal), readinessTimeoutMs, abort);
|
|
422
|
+
readinessPromise = check;
|
|
423
|
+
void check.then(
|
|
424
|
+
() => {
|
|
425
|
+
if (readinessPromise === check) readinessPromise = null;
|
|
426
|
+
},
|
|
427
|
+
() => {
|
|
428
|
+
if (readinessPromise === check) readinessPromise = null;
|
|
429
|
+
}
|
|
430
|
+
);
|
|
431
|
+
return check;
|
|
432
|
+
};
|
|
433
|
+
const run = () => {
|
|
434
|
+
if (runPromise) return runPromise;
|
|
435
|
+
if (state !== "starting") {
|
|
436
|
+
return Promise.reject(new Error("Artifact outbox dispatcher service cannot be restarted"));
|
|
437
|
+
}
|
|
438
|
+
runPromise = (async () => {
|
|
439
|
+
try {
|
|
440
|
+
await ready();
|
|
441
|
+
if (state === "draining") {
|
|
442
|
+
state = "stopped";
|
|
443
|
+
return;
|
|
444
|
+
}
|
|
445
|
+
const running = input.runtime.start();
|
|
446
|
+
state = "ready";
|
|
447
|
+
await running;
|
|
448
|
+
const exitWasDraining = state === "draining";
|
|
449
|
+
state = exitWasDraining ? "stopped" : "failed";
|
|
450
|
+
if (!exitWasDraining) {
|
|
451
|
+
throw new Error("Artifact outbox dispatcher exited without a drain request");
|
|
452
|
+
}
|
|
453
|
+
} catch (error) {
|
|
454
|
+
const caughtState = state;
|
|
455
|
+
if (caughtState !== "draining" && caughtState !== "stopped") state = "failed";
|
|
456
|
+
throw error;
|
|
457
|
+
}
|
|
458
|
+
})();
|
|
459
|
+
return runPromise;
|
|
460
|
+
};
|
|
461
|
+
const drain = (_reason = "shutdown") => {
|
|
462
|
+
if (state === "draining" || state === "stopped" || state === "failed") return false;
|
|
463
|
+
state = "draining";
|
|
464
|
+
input.runtime.drain();
|
|
465
|
+
return true;
|
|
466
|
+
};
|
|
467
|
+
const close = () => {
|
|
468
|
+
if (closePromise) return closePromise;
|
|
469
|
+
closePromise = (async () => {
|
|
470
|
+
drain("close");
|
|
471
|
+
if (runPromise) await runPromise.catch(() => void 0);
|
|
472
|
+
await input.runtime.stop();
|
|
473
|
+
if (state !== "failed") state = "stopped";
|
|
474
|
+
})();
|
|
475
|
+
return closePromise;
|
|
476
|
+
};
|
|
477
|
+
const fetch = async (request) => {
|
|
478
|
+
const url = new URL(request.url);
|
|
479
|
+
if (request.method !== "GET") {
|
|
480
|
+
return Response.json({ error: "method_not_allowed" }, { status: 405 });
|
|
481
|
+
}
|
|
482
|
+
if (url.pathname === "/healthz") {
|
|
483
|
+
const ok = state !== "failed" && state !== "stopped";
|
|
484
|
+
return Response.json(
|
|
485
|
+
{
|
|
486
|
+
service: input.serviceName,
|
|
487
|
+
component: "artifact-outbox-dispatcher",
|
|
488
|
+
environment: input.environment,
|
|
489
|
+
...input.deploymentRevision ? { deploymentRevision: input.deploymentRevision } : {},
|
|
490
|
+
state,
|
|
491
|
+
ok
|
|
492
|
+
},
|
|
493
|
+
{ status: ok ? 200 : 503 }
|
|
494
|
+
);
|
|
495
|
+
}
|
|
496
|
+
if (url.pathname === "/readyz") {
|
|
497
|
+
if (state !== "ready") {
|
|
498
|
+
return Response.json(
|
|
499
|
+
{
|
|
500
|
+
ok: false,
|
|
501
|
+
state,
|
|
502
|
+
checks: { databaseRole: { ok: false }, nats: { ok: false } }
|
|
503
|
+
},
|
|
504
|
+
{ status: 503 }
|
|
505
|
+
);
|
|
506
|
+
}
|
|
507
|
+
try {
|
|
508
|
+
await ready();
|
|
509
|
+
return Response.json({
|
|
510
|
+
ok: true,
|
|
511
|
+
state,
|
|
512
|
+
checks: { databaseRole: { ok: true }, nats: { ok: true } }
|
|
513
|
+
});
|
|
514
|
+
} catch {
|
|
515
|
+
return Response.json(
|
|
516
|
+
{
|
|
517
|
+
ok: false,
|
|
518
|
+
state,
|
|
519
|
+
checks: { databaseRole: { ok: false }, nats: { ok: false } }
|
|
520
|
+
},
|
|
521
|
+
{ status: 503 }
|
|
522
|
+
);
|
|
523
|
+
}
|
|
524
|
+
}
|
|
525
|
+
if (url.pathname === "/metrics") {
|
|
526
|
+
return new Response(await input.observability.prometheusMetrics(), {
|
|
527
|
+
status: 200,
|
|
528
|
+
headers: { "content-type": "text/plain; version=0.0.4; charset=utf-8" }
|
|
529
|
+
});
|
|
530
|
+
}
|
|
531
|
+
return Response.json({ error: "not_found" }, { status: 404 });
|
|
532
|
+
};
|
|
533
|
+
return Object.freeze({
|
|
534
|
+
state: () => state,
|
|
535
|
+
run,
|
|
536
|
+
drain,
|
|
537
|
+
close,
|
|
538
|
+
dispatchOnce: async () => await input.runtime.dispatcher.dispatchOnce(),
|
|
539
|
+
fetch
|
|
540
|
+
});
|
|
541
|
+
}
|
|
542
|
+
function readEditableArtifactOutboxSidecarEnvironment(environment = process.env) {
|
|
543
|
+
if (environment.OPENGENI_ARTIFACT_OUTBOX_ENABLED !== "true") return null;
|
|
544
|
+
const declaredDatabaseRole = required(environment, "OPENGENI_ARTIFACT_OUTBOX_DATABASE_ROLE");
|
|
545
|
+
if (declaredDatabaseRole !== EDITABLE_ARTIFACT_OUTBOX_DISPATCHER_DATABASE_ROLE) {
|
|
546
|
+
throw new Error("OPENGENI_ARTIFACT_OUTBOX_DATABASE_ROLE is invalid");
|
|
547
|
+
}
|
|
548
|
+
const result = {
|
|
549
|
+
databaseUrl: required(environment, EDITABLE_ARTIFACT_OUTBOX_DATABASE_URL_ENV),
|
|
550
|
+
declaredDatabaseRole,
|
|
551
|
+
owner: environment.OPENGENI_ARTIFACT_OUTBOX_OWNER?.trim() || `artifact-outbox-${process.pid}-${crypto.randomUUID()}`,
|
|
552
|
+
httpPort: integer(environment, "OPENGENI_ARTIFACT_OUTBOX_HTTP_PORT", 9466, 1, 65535),
|
|
553
|
+
databasePoolSize: integer(environment, "OPENGENI_ARTIFACT_OUTBOX_DB_POOL_SIZE", 4, 1, 8),
|
|
554
|
+
batchSize: integer(environment, "OPENGENI_ARTIFACT_OUTBOX_BATCH_SIZE", 32, 1, 1e3),
|
|
555
|
+
concurrency: integer(environment, "OPENGENI_ARTIFACT_OUTBOX_CONCURRENCY", 8, 1, 128),
|
|
556
|
+
leaseDurationMs: integer(
|
|
557
|
+
environment,
|
|
558
|
+
"OPENGENI_ARTIFACT_OUTBOX_LEASE_MS",
|
|
559
|
+
3e4,
|
|
560
|
+
1e3,
|
|
561
|
+
864e5
|
|
562
|
+
),
|
|
563
|
+
leaseRenewIntervalMs: integer(
|
|
564
|
+
environment,
|
|
565
|
+
"OPENGENI_ARTIFACT_OUTBOX_RENEW_MS",
|
|
566
|
+
1e4,
|
|
567
|
+
100,
|
|
568
|
+
43199999
|
|
569
|
+
),
|
|
570
|
+
pollIntervalMs: integer(environment, "OPENGENI_ARTIFACT_OUTBOX_POLL_MS", 500, 10, 6e4),
|
|
571
|
+
publishTimeoutMs: integer(
|
|
572
|
+
environment,
|
|
573
|
+
"OPENGENI_ARTIFACT_OUTBOX_PUBLISH_TIMEOUT_MS",
|
|
574
|
+
5e3,
|
|
575
|
+
100,
|
|
576
|
+
6e4
|
|
577
|
+
),
|
|
578
|
+
retryBaseMs: integer(environment, "OPENGENI_ARTIFACT_OUTBOX_RETRY_BASE_MS", 500, 10, 6e4),
|
|
579
|
+
retryMaxMs: integer(
|
|
580
|
+
environment,
|
|
581
|
+
"OPENGENI_ARTIFACT_OUTBOX_RETRY_MAX_MS",
|
|
582
|
+
6e4,
|
|
583
|
+
10,
|
|
584
|
+
864e5
|
|
585
|
+
)
|
|
586
|
+
};
|
|
587
|
+
if (result.leaseRenewIntervalMs >= result.leaseDurationMs) {
|
|
588
|
+
throw new Error("OPENGENI_ARTIFACT_OUTBOX_RENEW_MS must be less than lease duration");
|
|
589
|
+
}
|
|
590
|
+
if (result.retryBaseMs > result.retryMaxMs) {
|
|
591
|
+
throw new Error("OPENGENI_ARTIFACT_OUTBOX_RETRY_BASE_MS must not exceed retry max");
|
|
592
|
+
}
|
|
593
|
+
return Object.freeze(result);
|
|
594
|
+
}
|
|
595
|
+
async function createOutboxSidecarFromEnvironment(environment = process.env) {
|
|
596
|
+
const sidecar = readEditableArtifactOutboxSidecarEnvironment(environment);
|
|
597
|
+
if (!sidecar) return null;
|
|
598
|
+
const settings = getSettings();
|
|
599
|
+
const controlPlaneAuth = resolveNatsControlPlaneAuth(settings);
|
|
600
|
+
const natsAuth = controlPlaneAuth ? {
|
|
601
|
+
kind: "user-password",
|
|
602
|
+
user: controlPlaneAuth.user,
|
|
603
|
+
pass: controlPlaneAuth.password
|
|
604
|
+
} : { kind: "anonymous" };
|
|
605
|
+
const service = await createProductionEditableArtifactOutboxService({
|
|
606
|
+
settings,
|
|
607
|
+
databaseUrl: sidecar.databaseUrl,
|
|
608
|
+
declaredDatabaseRole: sidecar.declaredDatabaseRole,
|
|
609
|
+
natsUrl: settings.natsUrl,
|
|
610
|
+
natsAuth,
|
|
611
|
+
owner: sidecar.owner,
|
|
612
|
+
databasePoolSize: sidecar.databasePoolSize,
|
|
613
|
+
batchSize: sidecar.batchSize,
|
|
614
|
+
concurrency: sidecar.concurrency,
|
|
615
|
+
leaseDurationMs: sidecar.leaseDurationMs,
|
|
616
|
+
leaseRenewIntervalMs: sidecar.leaseRenewIntervalMs,
|
|
617
|
+
pollIntervalMs: sidecar.pollIntervalMs,
|
|
618
|
+
publishTimeoutMs: sidecar.publishTimeoutMs,
|
|
619
|
+
retryBaseMs: sidecar.retryBaseMs,
|
|
620
|
+
retryMaxMs: sidecar.retryMaxMs
|
|
621
|
+
});
|
|
622
|
+
return Object.freeze({ service, httpPort: sidecar.httpPort });
|
|
623
|
+
}
|
|
624
|
+
async function withTimeout(promise, milliseconds, abort) {
|
|
625
|
+
let timer;
|
|
626
|
+
try {
|
|
627
|
+
return await Promise.race([
|
|
628
|
+
promise,
|
|
629
|
+
new Promise((_resolve, reject) => {
|
|
630
|
+
timer = setTimeout(() => {
|
|
631
|
+
abort.abort();
|
|
632
|
+
reject(new Error("readiness check timed out"));
|
|
633
|
+
}, milliseconds);
|
|
634
|
+
})
|
|
635
|
+
]);
|
|
636
|
+
} finally {
|
|
637
|
+
if (timer) clearTimeout(timer);
|
|
638
|
+
}
|
|
639
|
+
}
|
|
640
|
+
function required(environment, name) {
|
|
641
|
+
const value = environment[name]?.trim();
|
|
642
|
+
if (!value) throw new Error(`${name} is required when artifact outbox dispatch is enabled`);
|
|
643
|
+
return value;
|
|
644
|
+
}
|
|
645
|
+
function integer(environment, name, fallback, minimum, maximum) {
|
|
646
|
+
const raw = environment[name];
|
|
647
|
+
const value = raw === void 0 ? fallback : Number(raw);
|
|
648
|
+
if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
|
|
649
|
+
throw new Error(`${name} is outside its allowed range`);
|
|
650
|
+
}
|
|
651
|
+
return value;
|
|
652
|
+
}
|
|
653
|
+
|
|
654
|
+
// src/artifact-outbox-entry.ts
|
|
655
|
+
async function runEditableArtifactOutboxSidecar(environment = process.env) {
|
|
656
|
+
const configured = await createOutboxSidecarFromEnvironment(environment);
|
|
657
|
+
if (!configured) throw new Error("Editable artifact outbox sidecar is disabled");
|
|
658
|
+
const server = Bun.serve({
|
|
659
|
+
hostname: "0.0.0.0",
|
|
660
|
+
port: configured.httpPort,
|
|
661
|
+
fetch: configured.service.fetch
|
|
662
|
+
});
|
|
663
|
+
const stop = () => configured.service.drain("process signal");
|
|
664
|
+
process.on("SIGTERM", stop);
|
|
665
|
+
process.on("SIGINT", stop);
|
|
666
|
+
try {
|
|
667
|
+
await configured.service.run();
|
|
668
|
+
} finally {
|
|
669
|
+
process.off("SIGTERM", stop);
|
|
670
|
+
process.off("SIGINT", stop);
|
|
671
|
+
server.stop(true);
|
|
672
|
+
await configured.service.close();
|
|
673
|
+
}
|
|
674
|
+
}
|
|
675
|
+
if (import.meta.main) {
|
|
676
|
+
await runEditableArtifactOutboxSidecar();
|
|
677
|
+
}
|
|
678
|
+
export {
|
|
679
|
+
runEditableArtifactOutboxSidecar
|
|
680
|
+
};
|
|
681
|
+
//# sourceMappingURL=artifact-outbox-entry.js.map
|