@tangle-network/agent-app 0.60.249 → 0.60.251
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/DesignCanvas-L6J72JQ2.js +15 -0
- package/dist/DesignCanvasEditor-QFQD63MR.js +18 -0
- package/dist/agent-enrollment/drizzle.js +3 -3
- package/dist/agent-enrollment/index.js +3 -3
- package/dist/app-auth/drizzle.d.ts +561 -0
- package/dist/app-auth/drizzle.js +72 -0
- package/dist/app-auth/drizzle.js.map +1 -0
- package/dist/app-auth/index.js +5 -3
- package/dist/app-auth/index.js.map +1 -1
- package/dist/app-oauth/drizzle.d.ts +2080 -0
- package/dist/app-oauth/drizzle.js +161 -0
- package/dist/app-oauth/drizzle.js.map +1 -0
- package/dist/app-oauth/index.d.ts +4 -0
- package/dist/app-oauth/index.js +8 -222
- package/dist/app-oauth/index.js.map +1 -1
- package/dist/app-oauth/issuer.d.ts +133 -0
- package/dist/app-oauth/issuer.js +247 -0
- package/dist/app-oauth/issuer.js.map +1 -0
- package/dist/assistant/index.js +13 -13
- package/dist/chat-react/index.js +4 -4
- package/dist/chat-routes/dispatch-first.d.ts +43 -0
- package/dist/chat-routes/index.js +37 -67
- package/dist/chat-routes/index.js.map +1 -1
- package/dist/chat-routes/promote-file-part.d.ts +2 -3
- package/dist/chat-routes/turn-execution.d.ts +3 -1
- package/dist/chat-routes/turn-route-contracts.d.ts +31 -0
- package/dist/chat-store/index.js +4 -4
- package/dist/{chunk-MY3EJJ6Y.js → chunk-4FEH6266.js} +2 -2
- package/dist/{chunk-5Y7Z5G3Y.js → chunk-4GCPADYG.js} +20 -336
- package/dist/chunk-4GCPADYG.js.map +1 -0
- package/dist/{chunk-X556WVBG.js → chunk-4ZSLX3LY.js} +2 -2
- package/dist/chunk-57XPEL7X.js +26 -0
- package/dist/chunk-57XPEL7X.js.map +1 -0
- package/dist/chunk-6Z7TZVKZ.js +26 -0
- package/dist/chunk-6Z7TZVKZ.js.map +1 -0
- package/dist/{chunk-7KKOFMLD.js → chunk-AWIQQEFP.js} +1 -1
- package/dist/chunk-AWIQQEFP.js.map +1 -0
- package/dist/{chunk-VBKP2NLI.js → chunk-BTKI4XMM.js} +2 -2
- package/dist/{chunk-63QAQP7I.js → chunk-CNBVWPQC.js} +7 -7
- package/dist/{chunk-FENBDSIW.js → chunk-CQGEGPY7.js} +75 -3
- package/dist/chunk-CQGEGPY7.js.map +1 -0
- package/dist/chunk-CTREXL3O.js +335 -0
- package/dist/chunk-CTREXL3O.js.map +1 -0
- package/dist/chunk-DLWO3J7D.js +238 -0
- package/dist/chunk-DLWO3J7D.js.map +1 -0
- package/dist/{chunk-LWSJK546.js → chunk-DSMGS4IV.js} +5 -5
- package/dist/{chunk-LWSJK546.js.map → chunk-DSMGS4IV.js.map} +1 -1
- package/dist/{chunk-BDCC6UVW.js → chunk-EFPIHR6F.js} +161 -40
- package/dist/chunk-EFPIHR6F.js.map +1 -0
- package/dist/chunk-FRAICFTZ.js +191 -0
- package/dist/chunk-FRAICFTZ.js.map +1 -0
- package/dist/chunk-GS7VWV26.js +61 -0
- package/dist/chunk-GS7VWV26.js.map +1 -0
- package/dist/{chunk-NMSAZFRL.js → chunk-H5GQMLHA.js} +2 -2
- package/dist/{chunk-OQE6WMDP.js → chunk-HN6MZ2XL.js} +5 -5
- package/dist/chunk-HY57QRRW.js +11 -0
- package/dist/chunk-HY57QRRW.js.map +1 -0
- package/dist/{chunk-TCGZFSN5.js → chunk-KH4QSBNI.js} +2 -2
- package/dist/{chunk-JH3CKHF4.js → chunk-KJODHPWM.js} +8 -8
- package/dist/chunk-LSBI5MWS.js +66 -0
- package/dist/chunk-LSBI5MWS.js.map +1 -0
- package/dist/chunk-MDRH3SDA.js +106 -0
- package/dist/chunk-MDRH3SDA.js.map +1 -0
- package/dist/{chunk-VBWYH7UZ.js → chunk-NHYRIM4I.js} +3 -3
- package/dist/{chunk-BYP54FMI.js → chunk-O2RCDK5D.js} +30 -15
- package/dist/{chunk-BYP54FMI.js.map → chunk-O2RCDK5D.js.map} +1 -1
- package/dist/{chunk-EWOJATDS.js → chunk-PDD5A43Y.js} +3 -3
- package/dist/{chunk-23JUSUUB.js → chunk-RZLCBWGG.js} +2 -2
- package/dist/chunk-SFZELD6V.js +52 -0
- package/dist/chunk-SFZELD6V.js.map +1 -0
- package/dist/{chunk-Y4W6GK5X.js → chunk-UGFCLD32.js} +2 -2
- package/dist/{chunk-ZGUXI5SI.js → chunk-VUBJZEZB.js} +2 -2
- package/dist/{chunk-LQYIBL3G.js → chunk-WL7PZK7Q.js} +71 -1
- package/dist/chunk-WL7PZK7Q.js.map +1 -0
- package/dist/{chunk-7HZCFG2A.js → chunk-WP2GYFZ4.js} +38 -1
- package/dist/chunk-WP2GYFZ4.js.map +1 -0
- package/dist/{chunk-JK7R7BZQ.js → chunk-ZWJ3SZ2G.js} +2 -2
- package/dist/crypto/digest.d.ts +2 -0
- package/dist/crypto/index.d.ts +1 -0
- package/dist/crypto/index.js +6 -2
- package/dist/design-canvas/index.js +5 -3
- package/dist/design-canvas/index.js.map +1 -1
- package/dist/design-canvas-react/engine.js +7 -5
- package/dist/design-canvas-react/index.js +14 -12
- package/dist/design-canvas-react/index.js.map +1 -1
- package/dist/design-canvas-react/lazy.js +1 -1
- package/dist/eval/index.d.ts +4 -0
- package/dist/eval/index.js +125 -0
- package/dist/eval/index.js.map +1 -1
- package/dist/eval/persona-driver.d.ts +37 -0
- package/dist/eval/research-plan.d.ts +25 -0
- package/dist/eval/research-plan.js +55 -0
- package/dist/eval/research-plan.js.map +1 -0
- package/dist/eval/scorecard.d.ts +38 -0
- package/dist/forms/blank.d.ts +2 -2
- package/dist/forms/index.js +4 -5
- package/dist/forms/index.js.map +1 -1
- package/dist/hosted-agent/application.js +2 -2
- package/dist/interactions/index.js +3 -3
- package/dist/knowledge/prelaunch-audit.d.ts +17 -0
- package/dist/knowledge/prelaunch-audit.js +67 -0
- package/dist/knowledge/prelaunch-audit.js.map +1 -0
- package/dist/media/drizzle.d.ts +207 -0
- package/dist/media/drizzle.js +26 -0
- package/dist/media/drizzle.js.map +1 -0
- package/dist/media/generate-request.d.ts +53 -0
- package/dist/media/generation-record.d.ts +68 -0
- package/dist/media/index.d.ts +13 -0
- package/dist/media/index.js +653 -0
- package/dist/media/index.js.map +1 -0
- package/dist/media/model-catalog.d.ts +109 -0
- package/dist/media/router-client.d.ts +40 -0
- package/dist/media/router-generation.d.ts +44 -0
- package/dist/media/speech-script.d.ts +20 -0
- package/dist/openui/index.js +1 -1
- package/dist/operator/index.js +4 -5
- package/dist/operator/index.js.map +1 -1
- package/dist/plans/decision.d.ts +48 -0
- package/dist/plans/drizzle.d.ts +25 -0
- package/dist/plans/drizzle.js +97 -0
- package/dist/plans/drizzle.js.map +1 -0
- package/dist/plans/index.d.ts +1 -1
- package/dist/plans/index.js +11 -3
- package/dist/platform/billing-config.d.ts +22 -0
- package/dist/platform/billing-config.js +36 -0
- package/dist/platform/billing-config.js.map +1 -0
- package/dist/platform/index.js +13 -11
- package/dist/platform/index.js.map +1 -1
- package/dist/preset-cloudflare/index.js +2 -1
- package/dist/preset-cloudflare/index.js.map +1 -1
- package/dist/profile/index.js +4 -5
- package/dist/profile/index.js.map +1 -1
- package/dist/public-consultation/index.js +13 -11
- package/dist/public-consultation/index.js.map +1 -1
- package/dist/runtime/telemetry-cap.d.ts +24 -0
- package/dist/runtime/telemetry-cap.js +36 -0
- package/dist/runtime/telemetry-cap.js.map +1 -0
- package/dist/sandbox/index.js +12 -9
- package/dist/sequences/index.js +4 -2
- package/dist/sequences/index.js.map +1 -1
- package/dist/skills-placement/box.d.ts +50 -0
- package/dist/skills-placement/box.js +204 -0
- package/dist/skills-placement/box.js.map +1 -0
- package/dist/skills-placement/index.js +8 -96
- package/dist/skills-placement/index.js.map +1 -1
- package/dist/spend/budget.d.ts +13 -0
- package/dist/spend/drizzle.d.ts +55 -0
- package/dist/spend/drizzle.js +131 -0
- package/dist/spend/drizzle.js.map +1 -0
- package/dist/spend/index.d.ts +2 -1
- package/dist/spend/index.js +77 -58
- package/dist/spend/index.js.map +1 -1
- package/dist/spend/platform-settlements.d.ts +46 -0
- package/dist/stream/index.js +19 -19
- package/dist/studio/generated-media/index.d.ts +6 -0
- package/dist/studio/generated-media/index.js +590 -0
- package/dist/studio/generated-media/index.js.map +1 -0
- package/dist/studio/generated-media/output.d.ts +27 -0
- package/dist/studio/generated-media/store.d.ts +175 -0
- package/dist/studio-react/download-generations.d.ts +7 -0
- package/dist/studio-react/index.d.ts +1 -0
- package/dist/studio-react/index.js +85 -0
- package/dist/studio-react/index.js.map +1 -1
- package/dist/studio-react/use-studio-route.d.ts +44 -0
- package/dist/teams/invitations-api.d.ts +4 -0
- package/dist/teams/invitations-api.js +44 -32
- package/dist/teams/invitations-api.js.map +1 -1
- package/dist/theme/dom.d.ts +22 -0
- package/dist/theme/dom.js +18 -0
- package/dist/theme/dom.js.map +1 -0
- package/dist/vault/collaboration.d.ts +83 -0
- package/dist/vault/collaboration.js +215 -0
- package/dist/vault/collaboration.js.map +1 -0
- package/dist/vault/server.js +6 -53
- package/dist/vault/server.js.map +1 -1
- package/dist/vault/store/coordinator.d.ts +64 -0
- package/dist/vault/store/index.d.ts +12 -0
- package/dist/vault/store/index.js +1202 -0
- package/dist/vault/store/index.js.map +1 -0
- package/dist/vault/store/paths.d.ts +65 -0
- package/dist/vault/store/revisions.d.ts +211 -0
- package/dist/vault/store/sandbox-sync.d.ts +74 -0
- package/dist/vault/store/store.d.ts +161 -0
- package/dist/vault/store/tree.d.ts +11 -0
- package/dist/web/entry-server.d.ts +7 -0
- package/dist/web/entry-server.js +29 -0
- package/dist/web/entry-server.js.map +1 -0
- package/dist/web/fetch-guard.d.ts +6 -0
- package/dist/web/index.d.ts +3 -0
- package/dist/web/index.js +20 -4
- package/dist/web/mime.d.ts +16 -0
- package/dist/web/rate-limit.d.ts +25 -0
- package/dist/web/timeout.d.ts +9 -0
- package/dist/web-react/agent-profile-editor.js +3 -3
- package/dist/web-react/api-access-panel.d.ts +4 -2
- package/dist/web-react/document.d.ts +41 -0
- package/dist/web-react/document.js +103 -0
- package/dist/web-react/document.js.map +1 -0
- package/dist/web-react/index.js +31 -31
- package/dist/workspace-react/index.js +5 -5
- package/package.json +95 -4
- package/dist/DesignCanvas-OW3W2QXW.js +0 -13
- package/dist/DesignCanvasEditor-TCHZF25W.js +0 -16
- package/dist/chunk-5Y7Z5G3Y.js.map +0 -1
- package/dist/chunk-7HZCFG2A.js.map +0 -1
- package/dist/chunk-7KKOFMLD.js.map +0 -1
- package/dist/chunk-BDCC6UVW.js.map +0 -1
- package/dist/chunk-FENBDSIW.js.map +0 -1
- package/dist/chunk-LQYIBL3G.js.map +0 -1
- /package/dist/{DesignCanvas-OW3W2QXW.js.map → DesignCanvas-L6J72JQ2.js.map} +0 -0
- /package/dist/{DesignCanvasEditor-TCHZF25W.js.map → DesignCanvasEditor-QFQD63MR.js.map} +0 -0
- /package/dist/{chunk-MY3EJJ6Y.js.map → chunk-4FEH6266.js.map} +0 -0
- /package/dist/{chunk-X556WVBG.js.map → chunk-4ZSLX3LY.js.map} +0 -0
- /package/dist/{chunk-VBKP2NLI.js.map → chunk-BTKI4XMM.js.map} +0 -0
- /package/dist/{chunk-63QAQP7I.js.map → chunk-CNBVWPQC.js.map} +0 -0
- /package/dist/{chunk-NMSAZFRL.js.map → chunk-H5GQMLHA.js.map} +0 -0
- /package/dist/{chunk-OQE6WMDP.js.map → chunk-HN6MZ2XL.js.map} +0 -0
- /package/dist/{chunk-TCGZFSN5.js.map → chunk-KH4QSBNI.js.map} +0 -0
- /package/dist/{chunk-JH3CKHF4.js.map → chunk-KJODHPWM.js.map} +0 -0
- /package/dist/{chunk-VBWYH7UZ.js.map → chunk-NHYRIM4I.js.map} +0 -0
- /package/dist/{chunk-EWOJATDS.js.map → chunk-PDD5A43Y.js.map} +0 -0
- /package/dist/{chunk-23JUSUUB.js.map → chunk-RZLCBWGG.js.map} +0 -0
- /package/dist/{chunk-Y4W6GK5X.js.map → chunk-UGFCLD32.js.map} +0 -0
- /package/dist/{chunk-ZGUXI5SI.js.map → chunk-VUBJZEZB.js.map} +0 -0
- /package/dist/{chunk-JK7R7BZQ.js.map → chunk-ZWJ3SZ2G.js.map} +0 -0
|
@@ -0,0 +1,1202 @@
|
|
|
1
|
+
import {
|
|
2
|
+
compareIncarnationBaseline
|
|
3
|
+
} from "../../chunk-GS7VWV26.js";
|
|
4
|
+
import {
|
|
5
|
+
sha256Hex
|
|
6
|
+
} from "../../chunk-HY57QRRW.js";
|
|
7
|
+
import {
|
|
8
|
+
VAULT_KV_KEY_MAX_BYTES,
|
|
9
|
+
VaultPathError,
|
|
10
|
+
VaultPrivateRuntimeFileError,
|
|
11
|
+
VaultStorageKeyError,
|
|
12
|
+
isHiddenVaultFilePath,
|
|
13
|
+
parseVaultPathErrorResponse,
|
|
14
|
+
validateVaultFilePath,
|
|
15
|
+
validateVaultMutationKeys,
|
|
16
|
+
validateWorkspaceId,
|
|
17
|
+
vaultErasureJobKey,
|
|
18
|
+
vaultErasureKey,
|
|
19
|
+
vaultErasurePrefix,
|
|
20
|
+
vaultHeadKey,
|
|
21
|
+
vaultHeadPathPrefix,
|
|
22
|
+
vaultHeadPrefix,
|
|
23
|
+
vaultMetaKey,
|
|
24
|
+
vaultOperationKey,
|
|
25
|
+
vaultPathErrorResponseBody,
|
|
26
|
+
vaultRevisionKey,
|
|
27
|
+
vaultRevisionPrefix
|
|
28
|
+
} from "../../chunk-FRAICFTZ.js";
|
|
29
|
+
import {
|
|
30
|
+
isWorkspaceFileExportable
|
|
31
|
+
} from "../../chunk-TXD5HXLE.js";
|
|
32
|
+
|
|
33
|
+
// src/vault/store/revisions.ts
|
|
34
|
+
var VAULT_HEAD_SCHEMA = "vault-head-v1";
|
|
35
|
+
var VAULT_REVISION_SCHEMA = "vault-revision-v1";
|
|
36
|
+
var VAULT_OPERATION_SCHEMA = "vault-operation-v1";
|
|
37
|
+
var VAULT_READ_CONVERGENCE_TIMEOUT_MS = 2e3;
|
|
38
|
+
var VAULT_READ_CONVERGENCE_INITIAL_DELAY_MS = 25;
|
|
39
|
+
var VAULT_READ_CONVERGENCE_MAX_DELAY_MS = 250;
|
|
40
|
+
var VAULT_LINEAGE_MAX_REVISIONS = 32;
|
|
41
|
+
var VaultReadConvergenceError = class extends Error {
|
|
42
|
+
code = "vault.read_not_converged";
|
|
43
|
+
retryable = true;
|
|
44
|
+
workspaceId;
|
|
45
|
+
path;
|
|
46
|
+
expectedRevision;
|
|
47
|
+
constructor(input = {}) {
|
|
48
|
+
const detail = typeof input === "string" ? { message: input } : input;
|
|
49
|
+
super(detail.message ?? "Vault read did not converge before the retry deadline");
|
|
50
|
+
this.name = "VaultReadConvergenceError";
|
|
51
|
+
this.workspaceId = detail.workspaceId;
|
|
52
|
+
this.path = detail.path;
|
|
53
|
+
this.expectedRevision = detail.expectedRevision;
|
|
54
|
+
}
|
|
55
|
+
};
|
|
56
|
+
function normalizeVaultWriterProvenance(writer, allowedSources) {
|
|
57
|
+
const supplied = writer.provenance;
|
|
58
|
+
const actor = writer.authKind === "operator" ? "unknown" : supplied?.actor ?? (writer.kind === "sandbox" ? "agent" : writer.kind === "frontend" ? "owner" : "unknown");
|
|
59
|
+
if (!["agent", "owner", "maintenance", "unknown"].includes(actor)) throw new Error("Invalid Vault provenance actor");
|
|
60
|
+
const source = supplied?.source ?? (writer.kind === "sandbox" ? "sandbox-sync" : writer.kind === "frontend" ? "vault-api" : "unknown");
|
|
61
|
+
if (!allowedSources.includes(source)) throw new Error("Invalid Vault provenance source");
|
|
62
|
+
const provenance = { actor, source };
|
|
63
|
+
for (const key of ["executionId", "threadId", "messageId"]) {
|
|
64
|
+
const value = supplied?.[key];
|
|
65
|
+
if (value === void 0) continue;
|
|
66
|
+
if (typeof value !== "string" || value.length > 128 || !/^(?:[A-Za-z0-9:_-]|%[A-Fa-f0-9]{2})+$/.test(value)) throw new Error(`Invalid Vault provenance ${key}`);
|
|
67
|
+
provenance[key] = value;
|
|
68
|
+
}
|
|
69
|
+
return { ...writer, provenance };
|
|
70
|
+
}
|
|
71
|
+
function vaultWriterActor(writer) {
|
|
72
|
+
if (writer.kind === "sandbox") return writer.id ? `sandbox:${writer.id}` : "vault:sandbox";
|
|
73
|
+
return writer.id ?? `vault:${writer.kind}`;
|
|
74
|
+
}
|
|
75
|
+
function positiveInteger(value) {
|
|
76
|
+
return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : void 0;
|
|
77
|
+
}
|
|
78
|
+
function vaultHeadSequence(state) {
|
|
79
|
+
return positiveInteger(state.sequence) ?? positiveInteger(state.metadata?.sequence) ?? (state.revision ? 1 : 0);
|
|
80
|
+
}
|
|
81
|
+
function vaultHeadCreation(metadata) {
|
|
82
|
+
const created = metadata?.created;
|
|
83
|
+
return created && typeof created.by === "string" && created.by && typeof created.at === "string" && created.at ? { by: created.by, at: created.at } : null;
|
|
84
|
+
}
|
|
85
|
+
function isRecord(value) {
|
|
86
|
+
return Boolean(value) && typeof value === "object" && !Array.isArray(value);
|
|
87
|
+
}
|
|
88
|
+
function parseVaultHeadMetadata(value) {
|
|
89
|
+
if (!isRecord(value) || value.schema !== VAULT_HEAD_SCHEMA) return null;
|
|
90
|
+
if (typeof value.revision !== "string" || !value.revision) return null;
|
|
91
|
+
if (typeof value.deleted !== "boolean") return null;
|
|
92
|
+
if (value.contentHash !== null && typeof value.contentHash !== "string") return null;
|
|
93
|
+
if (typeof value.operationId !== "string" || typeof value.updatedAt !== "string") return null;
|
|
94
|
+
if (!isRecord(value.writer) || !["frontend", "sandbox", "system"].includes(String(value.writer.kind))) return null;
|
|
95
|
+
return value;
|
|
96
|
+
}
|
|
97
|
+
function vaultHeadMatchesFence(state, fence) {
|
|
98
|
+
return state.revision === fence.revision && state.contentHash === fence.contentHash && state.deleted === fence.deleted && state.metadata?.operationId === fence.operationId;
|
|
99
|
+
}
|
|
100
|
+
async function readVaultHeadStateConverged(kv, workspaceId, path, fence, options = {}) {
|
|
101
|
+
const timeoutMs = options.timeoutMs ?? VAULT_READ_CONVERGENCE_TIMEOUT_MS;
|
|
102
|
+
const now = options.now ?? Date.now;
|
|
103
|
+
const sleep = options.sleep ?? ((delayMs2) => new Promise((resolve) => setTimeout(resolve, delayMs2)));
|
|
104
|
+
const startedAt = now();
|
|
105
|
+
let delayMs = VAULT_READ_CONVERGENCE_INITIAL_DELAY_MS;
|
|
106
|
+
while (true) {
|
|
107
|
+
const state = await readVaultHeadState(kv, workspaceId, path);
|
|
108
|
+
if (vaultHeadMatchesFence(state, fence)) return state;
|
|
109
|
+
const elapsedMs = now() - startedAt;
|
|
110
|
+
if (elapsedMs >= timeoutMs) {
|
|
111
|
+
throw new VaultReadConvergenceError({
|
|
112
|
+
message: `Vault head for ${path} did not expose fenced revision ${fence.revision} within ${timeoutMs}ms`,
|
|
113
|
+
workspaceId,
|
|
114
|
+
path,
|
|
115
|
+
expectedRevision: fence.revision
|
|
116
|
+
});
|
|
117
|
+
}
|
|
118
|
+
const remainingMs = timeoutMs - elapsedMs;
|
|
119
|
+
await sleep(Math.min(delayMs, remainingMs));
|
|
120
|
+
delayMs = Math.min(delayMs * 2, VAULT_READ_CONVERGENCE_MAX_DELAY_MS);
|
|
121
|
+
}
|
|
122
|
+
}
|
|
123
|
+
async function readVaultHeadStateForErasure(kv, workspaceId, path, fence, options = {}) {
|
|
124
|
+
const head = await readVaultHeadState(kv, workspaceId, path);
|
|
125
|
+
if (vaultHeadMatchesFence(head, fence)) return head;
|
|
126
|
+
let revision = head.metadata?.revision === head.revision && fence.path === path ? head.revision : null;
|
|
127
|
+
for (let read = 0; revision && read < VAULT_LINEAGE_MAX_REVISIONS; read++) {
|
|
128
|
+
const record = await kv.getWithMetadata(vaultRevisionKey(workspaceId, revision, path));
|
|
129
|
+
const metadata = record.metadata;
|
|
130
|
+
if (record.value === null || metadata?.schema !== VAULT_REVISION_SCHEMA || metadata.workspaceId !== workspaceId || metadata.path !== path || metadata.revision !== revision || metadata.outcome !== "committed" || metadata.parentRevision !== null && typeof metadata.parentRevision !== "string") break;
|
|
131
|
+
if (metadata.batchOperation && !await vaultOperationCommitted(kv, workspaceId, metadata.operationId, path)) break;
|
|
132
|
+
if (read === 0 && (metadata.contentHash !== head.contentHash || metadata.deleted !== head.deleted || metadata.operationId !== head.metadata?.operationId)) break;
|
|
133
|
+
if (revision === fence.revision) {
|
|
134
|
+
if (metadata.contentHash !== fence.contentHash || metadata.deleted !== fence.deleted || metadata.operationId !== fence.operationId) break;
|
|
135
|
+
const current = await readVaultHeadState(kv, workspaceId, path);
|
|
136
|
+
if (current.revision !== head.revision || current.contentHash !== head.contentHash || current.deleted !== head.deleted || current.metadata?.operationId !== head.metadata?.operationId) break;
|
|
137
|
+
return head;
|
|
138
|
+
}
|
|
139
|
+
revision = metadata.parentRevision;
|
|
140
|
+
}
|
|
141
|
+
return readVaultHeadStateConverged(kv, workspaceId, path, fence, options);
|
|
142
|
+
}
|
|
143
|
+
async function vaultOperationCommitted(kv, workspaceId, operationId, path) {
|
|
144
|
+
const operation = await kv.get(vaultOperationKey(workspaceId, operationId, path));
|
|
145
|
+
const state = operation ? JSON.parse(operation) : null;
|
|
146
|
+
return state?.schema === VAULT_OPERATION_SCHEMA && state.status === "committed";
|
|
147
|
+
}
|
|
148
|
+
async function readVaultHeadState(kv, workspaceId, path) {
|
|
149
|
+
const result = await kv.getWithMetadata(vaultHeadKey(workspaceId, path));
|
|
150
|
+
const metadata = parseVaultHeadMetadata(result.metadata);
|
|
151
|
+
if (metadata) {
|
|
152
|
+
if (metadata.batchOperation) {
|
|
153
|
+
if (!await vaultOperationCommitted(kv, workspaceId, metadata.operationId, path)) {
|
|
154
|
+
const revision = await kv.getWithMetadata(vaultRevisionKey(workspaceId, metadata.revision, path));
|
|
155
|
+
const revisionMetadata = revision.metadata;
|
|
156
|
+
const parentRevision = revisionMetadata?.parentRevision ?? null;
|
|
157
|
+
if (!parentRevision) {
|
|
158
|
+
return { revision: null, contentHash: null, deleted: true, content: null, metadata: null };
|
|
159
|
+
}
|
|
160
|
+
const parent = await kv.getWithMetadata(vaultRevisionKey(workspaceId, parentRevision, path));
|
|
161
|
+
const parentMetadata = parent.metadata;
|
|
162
|
+
if (!parentMetadata || parentMetadata.schema !== VAULT_REVISION_SCHEMA) {
|
|
163
|
+
throw new Error(`Vault batch parent revision is missing: ${parentRevision}`);
|
|
164
|
+
}
|
|
165
|
+
return {
|
|
166
|
+
revision: parentRevision,
|
|
167
|
+
contentHash: parentMetadata.contentHash,
|
|
168
|
+
deleted: parentMetadata.deleted,
|
|
169
|
+
content: parentMetadata.deleted ? null : parent.value,
|
|
170
|
+
metadata: null,
|
|
171
|
+
sequence: positiveInteger(parentMetadata.sequence) ?? 1
|
|
172
|
+
};
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
return {
|
|
176
|
+
revision: metadata.revision,
|
|
177
|
+
contentHash: metadata.contentHash,
|
|
178
|
+
deleted: metadata.deleted,
|
|
179
|
+
content: metadata.deleted ? null : result.value,
|
|
180
|
+
metadata
|
|
181
|
+
};
|
|
182
|
+
}
|
|
183
|
+
if (result.value === null) {
|
|
184
|
+
return { revision: null, contentHash: null, deleted: true, content: null, metadata: null };
|
|
185
|
+
}
|
|
186
|
+
const contentHash = await sha256Hex(result.value);
|
|
187
|
+
const legacyRevision = await sha256Hex(`${path}\0${contentHash}`);
|
|
188
|
+
return {
|
|
189
|
+
revision: `legacy-${legacyRevision}`,
|
|
190
|
+
contentHash,
|
|
191
|
+
deleted: false,
|
|
192
|
+
content: result.value,
|
|
193
|
+
metadata: null
|
|
194
|
+
};
|
|
195
|
+
}
|
|
196
|
+
async function revisionIdFor(request, change, contentHash) {
|
|
197
|
+
return sha256Hex([
|
|
198
|
+
request.workspaceId,
|
|
199
|
+
request.operationId,
|
|
200
|
+
change.kind,
|
|
201
|
+
change.path,
|
|
202
|
+
change.expectedRevision ?? "absent",
|
|
203
|
+
contentHash ?? "deleted"
|
|
204
|
+
].join("\0"));
|
|
205
|
+
}
|
|
206
|
+
async function ensureRevisionRecord(kv, metadata, content) {
|
|
207
|
+
const key = vaultRevisionKey(metadata.workspaceId, metadata.revision, metadata.path);
|
|
208
|
+
const existing = await kv.getWithMetadata(key);
|
|
209
|
+
if (existing.value !== null) return;
|
|
210
|
+
await kv.put(key, content, { metadata });
|
|
211
|
+
}
|
|
212
|
+
async function applyVaultMutationBatch(kv, request, readHead = (workspaceId, path) => readVaultHeadState(kv, workspaceId, path), policy = {}) {
|
|
213
|
+
if (policy.normalizeWriter) request = { ...request, writer: policy.normalizeWriter(request.writer) };
|
|
214
|
+
if (!request.operationId) throw new Error("Vault mutation operationId is required");
|
|
215
|
+
if (request.changes.length === 0) return { status: "applied", files: [] };
|
|
216
|
+
validateVaultMutationKeys(request);
|
|
217
|
+
if (new Set(request.changes.map((change) => change.path)).size !== request.changes.length) {
|
|
218
|
+
throw new Error("Vault mutation contains duplicate paths");
|
|
219
|
+
}
|
|
220
|
+
const prepared = await Promise.all(request.changes.map(async (change) => {
|
|
221
|
+
if (change.kind === "put" && typeof change.content !== "string") {
|
|
222
|
+
throw new Error(`Vault put requires content: ${change.path}`);
|
|
223
|
+
}
|
|
224
|
+
const content = change.kind === "put" ? change.content : "";
|
|
225
|
+
const contentHash = change.kind === "put" ? await sha256Hex(content) : null;
|
|
226
|
+
const current = await readHead(request.workspaceId, change.path);
|
|
227
|
+
const alreadyApplied = current.metadata?.operationId === request.operationId && current.deleted === (change.kind === "delete") && current.contentHash === contentHash;
|
|
228
|
+
return {
|
|
229
|
+
change,
|
|
230
|
+
current,
|
|
231
|
+
content,
|
|
232
|
+
contentHash,
|
|
233
|
+
revision: alreadyApplied && current.revision ? current.revision : await revisionIdFor(request, change, contentHash),
|
|
234
|
+
sequence: vaultHeadSequence(current) + (alreadyApplied ? 0 : 1),
|
|
235
|
+
alreadyApplied
|
|
236
|
+
};
|
|
237
|
+
}));
|
|
238
|
+
validateVaultMutationKeys({
|
|
239
|
+
...request,
|
|
240
|
+
changes: prepared.map(({ change, revision }) => ({ path: change.path, revision }))
|
|
241
|
+
});
|
|
242
|
+
const conflicting = prepared.filter(({ change, current, alreadyApplied }) => !alreadyApplied && current.revision !== change.expectedRevision);
|
|
243
|
+
if (conflicting.length > 0) {
|
|
244
|
+
const createdAt = (/* @__PURE__ */ new Date()).toISOString();
|
|
245
|
+
const blocked = prepared.filter(({ alreadyApplied }) => !alreadyApplied);
|
|
246
|
+
await Promise.all(blocked.map(async ({ change, content, contentHash, revision }) => {
|
|
247
|
+
await ensureRevisionRecord(kv, {
|
|
248
|
+
schema: VAULT_REVISION_SCHEMA,
|
|
249
|
+
workspaceId: request.workspaceId,
|
|
250
|
+
path: change.path,
|
|
251
|
+
revision,
|
|
252
|
+
parentRevision: change.expectedRevision,
|
|
253
|
+
contentHash,
|
|
254
|
+
deleted: change.kind === "delete",
|
|
255
|
+
operationId: request.operationId,
|
|
256
|
+
createdAt,
|
|
257
|
+
writer: request.writer,
|
|
258
|
+
outcome: "conflict"
|
|
259
|
+
}, content);
|
|
260
|
+
}));
|
|
261
|
+
return {
|
|
262
|
+
status: "conflict",
|
|
263
|
+
conflicts: blocked.map(({ change, current, revision }) => ({
|
|
264
|
+
path: change.path,
|
|
265
|
+
expectedRevision: change.expectedRevision,
|
|
266
|
+
currentRevision: current.revision,
|
|
267
|
+
conflictRevision: revision
|
|
268
|
+
}))
|
|
269
|
+
};
|
|
270
|
+
}
|
|
271
|
+
const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
|
|
272
|
+
const isBatch = prepared.length > 1 && prepared.some(({ alreadyApplied }) => !alreadyApplied);
|
|
273
|
+
if (isBatch) {
|
|
274
|
+
const operation = { schema: VAULT_OPERATION_SCHEMA, status: "preparing" };
|
|
275
|
+
await kv.put(vaultOperationKey(request.workspaceId, request.operationId), JSON.stringify(operation));
|
|
276
|
+
}
|
|
277
|
+
for (const item of prepared) {
|
|
278
|
+
const { change, current, content, contentHash, revision, sequence, alreadyApplied } = item;
|
|
279
|
+
if (alreadyApplied) continue;
|
|
280
|
+
if (current.metadata === null && current.content !== null && current.revision && current.contentHash) {
|
|
281
|
+
const legacyWriter = { kind: "system", id: "legacy-import" };
|
|
282
|
+
await ensureRevisionRecord(kv, {
|
|
283
|
+
schema: VAULT_REVISION_SCHEMA,
|
|
284
|
+
workspaceId: request.workspaceId,
|
|
285
|
+
path: change.path,
|
|
286
|
+
revision: current.revision,
|
|
287
|
+
parentRevision: null,
|
|
288
|
+
contentHash: current.contentHash,
|
|
289
|
+
deleted: false,
|
|
290
|
+
operationId: `legacy:${current.revision}`,
|
|
291
|
+
createdAt: updatedAt,
|
|
292
|
+
writer: policy.normalizeWriter?.(legacyWriter) ?? legacyWriter,
|
|
293
|
+
outcome: "committed"
|
|
294
|
+
}, current.content);
|
|
295
|
+
}
|
|
296
|
+
const revisionMetadata = {
|
|
297
|
+
schema: VAULT_REVISION_SCHEMA,
|
|
298
|
+
contentBytes: new TextEncoder().encode(content).byteLength,
|
|
299
|
+
workspaceId: request.workspaceId,
|
|
300
|
+
path: change.path,
|
|
301
|
+
revision,
|
|
302
|
+
parentRevision: current.revision,
|
|
303
|
+
contentHash,
|
|
304
|
+
deleted: change.kind === "delete",
|
|
305
|
+
operationId: request.operationId,
|
|
306
|
+
createdAt: updatedAt,
|
|
307
|
+
writer: request.writer,
|
|
308
|
+
outcome: "committed",
|
|
309
|
+
batchOperation: isBatch || void 0,
|
|
310
|
+
sequence,
|
|
311
|
+
storeFormat: change.storeFormat
|
|
312
|
+
};
|
|
313
|
+
await ensureRevisionRecord(kv, revisionMetadata, content);
|
|
314
|
+
const live = !current.deleted && current.revision !== null;
|
|
315
|
+
const created = change.kind === "delete" || live ? vaultHeadCreation(current.metadata) ?? void 0 : { by: vaultWriterActor(request.writer), at: updatedAt };
|
|
316
|
+
const headMetadata = {
|
|
317
|
+
schema: VAULT_HEAD_SCHEMA,
|
|
318
|
+
revision,
|
|
319
|
+
contentHash,
|
|
320
|
+
deleted: change.kind === "delete",
|
|
321
|
+
operationId: request.operationId,
|
|
322
|
+
updatedAt,
|
|
323
|
+
writer: request.writer,
|
|
324
|
+
batchOperation: isBatch || void 0,
|
|
325
|
+
sequence,
|
|
326
|
+
created,
|
|
327
|
+
storeFormat: change.storeFormat
|
|
328
|
+
};
|
|
329
|
+
await kv.put(vaultHeadKey(request.workspaceId, change.path), content, { metadata: headMetadata });
|
|
330
|
+
}
|
|
331
|
+
if (isBatch) {
|
|
332
|
+
const operation = { schema: VAULT_OPERATION_SCHEMA, status: "committed" };
|
|
333
|
+
await kv.put(vaultOperationKey(request.workspaceId, request.operationId), JSON.stringify(operation));
|
|
334
|
+
}
|
|
335
|
+
return {
|
|
336
|
+
status: "applied",
|
|
337
|
+
files: prepared.map(({ change, current, contentHash, revision, sequence, alreadyApplied }) => ({
|
|
338
|
+
path: change.path,
|
|
339
|
+
revision,
|
|
340
|
+
contentHash,
|
|
341
|
+
deleted: change.kind === "delete",
|
|
342
|
+
sequence,
|
|
343
|
+
updatedAt: alreadyApplied ? current.metadata?.updatedAt : updatedAt
|
|
344
|
+
}))
|
|
345
|
+
};
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
// src/vault/store/tree.ts
|
|
349
|
+
function buildTreeFromPaths(paths) {
|
|
350
|
+
const tree = {};
|
|
351
|
+
for (const path of paths) {
|
|
352
|
+
if (!isWorkspaceFileExportable(path)) continue;
|
|
353
|
+
const parts = path.split("/");
|
|
354
|
+
let current = tree;
|
|
355
|
+
parts.forEach((name, i) => {
|
|
356
|
+
const isFile = i === parts.length - 1;
|
|
357
|
+
const entry = current[name] ??= {
|
|
358
|
+
node: { name, path: parts.slice(0, i + 1).join("/"), type: isFile ? "file" : "directory" },
|
|
359
|
+
children: {}
|
|
360
|
+
};
|
|
361
|
+
if (isFile) entry.node.type = "file";
|
|
362
|
+
current = entry.children;
|
|
363
|
+
});
|
|
364
|
+
}
|
|
365
|
+
function toNodes(map) {
|
|
366
|
+
return Object.values(map).map(({ node, children }) => {
|
|
367
|
+
const childNodes = toNodes(children);
|
|
368
|
+
if (childNodes.length > 0 || node.type === "directory") {
|
|
369
|
+
return { ...node, type: "directory", children: childNodes };
|
|
370
|
+
}
|
|
371
|
+
return node;
|
|
372
|
+
}).sort((a, b) => {
|
|
373
|
+
if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
|
|
374
|
+
return a.name.localeCompare(b.name);
|
|
375
|
+
});
|
|
376
|
+
}
|
|
377
|
+
return toNodes(tree);
|
|
378
|
+
}
|
|
379
|
+
function flattenVaultTreePaths(nodes) {
|
|
380
|
+
return nodes.flatMap((node) => {
|
|
381
|
+
if (node.type === "file") return [node.path];
|
|
382
|
+
return node.children ? flattenVaultTreePaths(node.children) : [];
|
|
383
|
+
});
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
// src/vault/store/store.ts
|
|
387
|
+
var VaultFileNotFoundError = class extends VaultPathError {
|
|
388
|
+
code = "vault.file_not_found";
|
|
389
|
+
constructor(filePath) {
|
|
390
|
+
super(`File not found: ${filePath}`, filePath);
|
|
391
|
+
this.name = "VaultFileNotFoundError";
|
|
392
|
+
}
|
|
393
|
+
};
|
|
394
|
+
var VaultConflictError = class extends Error {
|
|
395
|
+
code = "vault.conflict";
|
|
396
|
+
conflicts;
|
|
397
|
+
constructor(result) {
|
|
398
|
+
super(`Vault conflict: ${result.conflicts.map((conflict) => conflict.path).join(", ")}`);
|
|
399
|
+
this.name = "VaultConflictError";
|
|
400
|
+
this.conflicts = result.conflicts;
|
|
401
|
+
}
|
|
402
|
+
};
|
|
403
|
+
var VAULT_HISTORY_MAX_REVISIONS = 20;
|
|
404
|
+
var VAULT_REVISION_ID = /^[A-Za-z0-9_-]{1,128}$/;
|
|
405
|
+
var HIDDEN_VAULT_PURGE_MARKER = "hidden-path-purge-v1";
|
|
406
|
+
function revisionRecordFor(metadata, workspaceId, path) {
|
|
407
|
+
const record = metadata;
|
|
408
|
+
if (!record || record.schema !== VAULT_REVISION_SCHEMA) return null;
|
|
409
|
+
if (record.workspaceId !== workspaceId || record.path !== path) return null;
|
|
410
|
+
return record;
|
|
411
|
+
}
|
|
412
|
+
function createVaultRuntime(config) {
|
|
413
|
+
let kv = null;
|
|
414
|
+
let coordinator = null;
|
|
415
|
+
const localMutationQueues = /* @__PURE__ */ new Map();
|
|
416
|
+
function setVaultKV(next) {
|
|
417
|
+
kv = next;
|
|
418
|
+
}
|
|
419
|
+
function setVaultCoordinator(next) {
|
|
420
|
+
coordinator = next;
|
|
421
|
+
}
|
|
422
|
+
function getVaultCoordinator() {
|
|
423
|
+
return coordinator;
|
|
424
|
+
}
|
|
425
|
+
function getVaultKV() {
|
|
426
|
+
if (!kv) throw new Error("VAULT_KV not initialized. Call setVaultKV() first.");
|
|
427
|
+
return kv;
|
|
428
|
+
}
|
|
429
|
+
async function postVaultCoordinator(namespace, workspaceId, route, body) {
|
|
430
|
+
const headers = config.coordinatorHeaders ? await config.coordinatorHeaders(workspaceId) : { "Content-Type": "application/json" };
|
|
431
|
+
return namespace.get(namespace.idFromName(workspaceId)).fetch(`https://session-stream.internal/vault/${route}`, {
|
|
432
|
+
method: "POST",
|
|
433
|
+
headers,
|
|
434
|
+
body: JSON.stringify(body)
|
|
435
|
+
});
|
|
436
|
+
}
|
|
437
|
+
async function throwVaultCoordinatorError(response, fallback) {
|
|
438
|
+
const detail = await response.json().catch(() => null);
|
|
439
|
+
const pathError = parseVaultPathErrorResponse(detail);
|
|
440
|
+
if (pathError) throw pathError;
|
|
441
|
+
if (typeof detail?.error === "object") {
|
|
442
|
+
const decoded = config.decodeCoordinatorError?.(detail.error, fallback);
|
|
443
|
+
if (decoded) throw decoded;
|
|
444
|
+
if (detail.error.code === "vault.read_not_converged") {
|
|
445
|
+
throw new VaultReadConvergenceError({
|
|
446
|
+
message: detail.error.message,
|
|
447
|
+
workspaceId: detail.error.workspaceId,
|
|
448
|
+
path: detail.error.path,
|
|
449
|
+
expectedRevision: detail.error.expectedRevision
|
|
450
|
+
});
|
|
451
|
+
}
|
|
452
|
+
}
|
|
453
|
+
const message = typeof detail?.error === "string" ? detail.error : detail?.error?.message;
|
|
454
|
+
throw new Error(`${fallback} (${response.status})${message ? `: ${message}` : ""}`);
|
|
455
|
+
}
|
|
456
|
+
function enqueueLocalVaultMutation(workspaceId, run) {
|
|
457
|
+
const previous = localMutationQueues.get(workspaceId) ?? Promise.resolve();
|
|
458
|
+
const next = previous.catch(() => void 0).then(run);
|
|
459
|
+
localMutationQueues.set(workspaceId, next.then(() => void 0, () => void 0));
|
|
460
|
+
return next;
|
|
461
|
+
}
|
|
462
|
+
async function commitVaultMutation(request) {
|
|
463
|
+
validateWorkspaceId(request.workspaceId);
|
|
464
|
+
for (const change of request.changes) validateVaultFilePath(change.path);
|
|
465
|
+
const namespace = coordinator;
|
|
466
|
+
if (!namespace) {
|
|
467
|
+
return enqueueLocalVaultMutation(request.workspaceId, async () => {
|
|
468
|
+
await config.beforeLocalMutation?.(getVaultKV(), request);
|
|
469
|
+
return applyVaultMutationBatch(getVaultKV(), request, void 0, config.mutationPolicy);
|
|
470
|
+
});
|
|
471
|
+
}
|
|
472
|
+
const response = await postVaultCoordinator(namespace, request.workspaceId, "mutate", request);
|
|
473
|
+
if (response.status !== 200 && response.status !== 409) {
|
|
474
|
+
await throwVaultCoordinatorError(response, "Vault mutation coordinator failed");
|
|
475
|
+
}
|
|
476
|
+
return response.json();
|
|
477
|
+
}
|
|
478
|
+
async function readVaultFileState(workspaceId, filePath) {
|
|
479
|
+
validateVaultFilePath(filePath);
|
|
480
|
+
validateWorkspaceId(workspaceId);
|
|
481
|
+
const namespace = coordinator;
|
|
482
|
+
if (!namespace) return readVaultHeadState(getVaultKV(), workspaceId, filePath);
|
|
483
|
+
const response = await postVaultCoordinator(namespace, workspaceId, "head/get", { workspaceId, path: filePath });
|
|
484
|
+
if (!response.ok) await throwVaultCoordinatorError(response, "Vault head read failed");
|
|
485
|
+
const body = await response.json();
|
|
486
|
+
return body.state;
|
|
487
|
+
}
|
|
488
|
+
return {
|
|
489
|
+
setVaultKV,
|
|
490
|
+
getVaultKV,
|
|
491
|
+
setVaultCoordinator,
|
|
492
|
+
getVaultCoordinator,
|
|
493
|
+
postVaultCoordinator,
|
|
494
|
+
throwVaultCoordinatorError,
|
|
495
|
+
enqueueLocalVaultMutation,
|
|
496
|
+
commitVaultMutation,
|
|
497
|
+
readVaultFileState
|
|
498
|
+
};
|
|
499
|
+
}
|
|
500
|
+
function createVaultFiles(runtime, config) {
|
|
501
|
+
const { getVaultKV, getVaultCoordinator, postVaultCoordinator, throwVaultCoordinatorError, commitVaultMutation, readVaultFileState } = runtime;
|
|
502
|
+
async function expectedRevisionFor(workspaceId, filePath, options) {
|
|
503
|
+
if (options && Object.prototype.hasOwnProperty.call(options, "expectedRevision")) {
|
|
504
|
+
return options.expectedRevision ?? null;
|
|
505
|
+
}
|
|
506
|
+
return (await readVaultFileState(workspaceId, filePath)).revision;
|
|
507
|
+
}
|
|
508
|
+
async function commitSingleVaultMutation(workspaceId, change, options) {
|
|
509
|
+
const result = await commitVaultMutation({
|
|
510
|
+
workspaceId,
|
|
511
|
+
operationId: options?.operationId ?? crypto.randomUUID(),
|
|
512
|
+
writer: options?.writer ?? { kind: "system" },
|
|
513
|
+
changes: [{
|
|
514
|
+
...change,
|
|
515
|
+
expectedRevision: await expectedRevisionFor(workspaceId, change.path, options)
|
|
516
|
+
}]
|
|
517
|
+
});
|
|
518
|
+
if (result.status === "conflict") throw new VaultConflictError(result);
|
|
519
|
+
const file = result.files[0];
|
|
520
|
+
if (!file) throw new Error(`Vault mutation returned no result for ${change.path}`);
|
|
521
|
+
return file;
|
|
522
|
+
}
|
|
523
|
+
function storedFile(filePath, content, revision, contentHash) {
|
|
524
|
+
const parsed = config.codec.parse(content);
|
|
525
|
+
const mimeType = parsed.succeeded && typeof parsed.frontmatter.mime === "string" ? parsed.frontmatter.mime : void 0;
|
|
526
|
+
return {
|
|
527
|
+
path: filePath,
|
|
528
|
+
content,
|
|
529
|
+
frontmatter: parsed.succeeded ? parsed.frontmatter : {},
|
|
530
|
+
body: parsed.succeeded ? parsed.body : parsed.raw,
|
|
531
|
+
parseError: parsed.succeeded ? void 0 : parsed.error,
|
|
532
|
+
mimeType,
|
|
533
|
+
revision,
|
|
534
|
+
contentHash
|
|
535
|
+
};
|
|
536
|
+
}
|
|
537
|
+
function getVaultRoot(workspaceId) {
|
|
538
|
+
validateWorkspaceId(workspaceId);
|
|
539
|
+
return vaultHeadPrefix(workspaceId).slice(0, -1);
|
|
540
|
+
}
|
|
541
|
+
async function writeVaultFile(workspaceId, filePath, content, options) {
|
|
542
|
+
validateVaultFilePath(filePath);
|
|
543
|
+
validateWorkspaceId(workspaceId);
|
|
544
|
+
const fileContent = config.codec.serialize(content.frontmatter, content.body);
|
|
545
|
+
const result = await commitSingleVaultMutation(workspaceId, { path: filePath, kind: "put", content: fileContent }, options);
|
|
546
|
+
if (!result.contentHash) throw new Error(`Vault put returned no content hash for ${filePath}`);
|
|
547
|
+
return {
|
|
548
|
+
path: filePath,
|
|
549
|
+
content: fileContent,
|
|
550
|
+
frontmatter: content.frontmatter,
|
|
551
|
+
body: content.body,
|
|
552
|
+
revision: result.revision,
|
|
553
|
+
contentHash: result.contentHash
|
|
554
|
+
};
|
|
555
|
+
}
|
|
556
|
+
async function writeVaultRawFile(workspaceId, filePath, content, options) {
|
|
557
|
+
validateVaultFilePath(filePath);
|
|
558
|
+
validateWorkspaceId(workspaceId);
|
|
559
|
+
const result = await commitSingleVaultMutation(workspaceId, { path: filePath, kind: "put", content }, options);
|
|
560
|
+
if (!result.contentHash) throw new Error(`Vault put returned no content hash for ${filePath}`);
|
|
561
|
+
const { mimeType: _mimeType, ...file } = storedFile(filePath, content, result.revision, result.contentHash);
|
|
562
|
+
return file;
|
|
563
|
+
}
|
|
564
|
+
async function readVaultFile(workspaceId, filePath) {
|
|
565
|
+
validateVaultFilePath(filePath);
|
|
566
|
+
validateWorkspaceId(workspaceId);
|
|
567
|
+
const state = await readVaultFileState(workspaceId, filePath);
|
|
568
|
+
if (state.deleted || state.content === null || !state.revision || !state.contentHash) {
|
|
569
|
+
throw new VaultFileNotFoundError(filePath);
|
|
570
|
+
}
|
|
571
|
+
return storedFile(filePath, state.content, state.revision, state.contentHash);
|
|
572
|
+
}
|
|
573
|
+
async function deleteVaultFile(workspaceId, filePath, options) {
|
|
574
|
+
validateVaultFilePath(filePath);
|
|
575
|
+
validateWorkspaceId(workspaceId);
|
|
576
|
+
await config.beforeDelete?.(workspaceId, filePath);
|
|
577
|
+
await commitSingleVaultMutation(workspaceId, { path: filePath, kind: "delete" }, options);
|
|
578
|
+
}
|
|
579
|
+
async function listVaultHeadPage(workspaceId, options = {}) {
|
|
580
|
+
validateWorkspaceId(workspaceId);
|
|
581
|
+
const pathPrefix = options.prefix ?? "";
|
|
582
|
+
const namespace = getVaultCoordinator();
|
|
583
|
+
if (namespace) {
|
|
584
|
+
const response = await postVaultCoordinator(namespace, workspaceId, "head/list", { workspaceId, ...options });
|
|
585
|
+
if (!response.ok) await throwVaultCoordinatorError(response, "Vault head listing failed");
|
|
586
|
+
const page = await response.json();
|
|
587
|
+
return {
|
|
588
|
+
...page,
|
|
589
|
+
entries: page.entries.filter((entry) => isWorkspaceFileExportable(entry.path) && entry.path.startsWith(pathPrefix))
|
|
590
|
+
};
|
|
591
|
+
}
|
|
592
|
+
const prefix = vaultHeadPrefix(workspaceId);
|
|
593
|
+
const list = await getVaultKV().list({
|
|
594
|
+
prefix: vaultHeadPathPrefix(workspaceId, pathPrefix),
|
|
595
|
+
cursor: options.cursor,
|
|
596
|
+
...options.limit === void 0 ? {} : { limit: options.limit }
|
|
597
|
+
});
|
|
598
|
+
if (!list.list_complete && !list.cursor) {
|
|
599
|
+
throw new Error(`Vault KV listing did not provide a cursor for ${workspaceId}`);
|
|
600
|
+
}
|
|
601
|
+
const entries = (await Promise.all(list.keys.map(async (key) => {
|
|
602
|
+
const path = key.name.slice(prefix.length);
|
|
603
|
+
if (!isWorkspaceFileExportable(path)) return null;
|
|
604
|
+
validateVaultFilePath(path);
|
|
605
|
+
const metadata = parseVaultHeadMetadata(key.metadata);
|
|
606
|
+
if (metadata && !metadata.batchOperation) {
|
|
607
|
+
return { path, revision: metadata.revision, contentHash: metadata.contentHash, deleted: metadata.deleted };
|
|
608
|
+
}
|
|
609
|
+
const state = await readVaultHeadState(getVaultKV(), workspaceId, path);
|
|
610
|
+
return { path, revision: state.revision, contentHash: state.contentHash, deleted: state.deleted };
|
|
611
|
+
}))).filter((entry) => entry !== null);
|
|
612
|
+
return {
|
|
613
|
+
entries,
|
|
614
|
+
complete: list.list_complete,
|
|
615
|
+
cursor: list.list_complete ? null : list.cursor
|
|
616
|
+
};
|
|
617
|
+
}
|
|
618
|
+
async function listVaultFilePaths(workspaceId) {
|
|
619
|
+
validateWorkspaceId(workspaceId);
|
|
620
|
+
const paths = [];
|
|
621
|
+
let cursor;
|
|
622
|
+
do {
|
|
623
|
+
const page = await listVaultHeadPage(workspaceId, { cursor });
|
|
624
|
+
paths.push(...page.entries.filter((entry) => !entry.deleted).map((entry) => entry.path));
|
|
625
|
+
cursor = page.cursor ?? void 0;
|
|
626
|
+
} while (cursor);
|
|
627
|
+
return paths;
|
|
628
|
+
}
|
|
629
|
+
async function listVaultTree(workspaceId) {
|
|
630
|
+
return buildTreeFromPaths(await listVaultFilePaths(workspaceId));
|
|
631
|
+
}
|
|
632
|
+
return {
|
|
633
|
+
getVaultRoot,
|
|
634
|
+
writeVaultFile,
|
|
635
|
+
writeVaultRawFile,
|
|
636
|
+
readVaultFile,
|
|
637
|
+
deleteVaultFile,
|
|
638
|
+
listVaultHeadPage,
|
|
639
|
+
listVaultFilePaths,
|
|
640
|
+
listVaultTree
|
|
641
|
+
};
|
|
642
|
+
}
|
|
643
|
+
function createVaultHistory(runtime) {
|
|
644
|
+
const { getVaultKV, readVaultFileState } = runtime;
|
|
645
|
+
async function findVaultRevisionWithContent(workspaceId, path, headRevision, contentHash, options = {}) {
|
|
646
|
+
validateVaultFilePath(path);
|
|
647
|
+
validateWorkspaceId(workspaceId);
|
|
648
|
+
const store = getVaultKV();
|
|
649
|
+
let revision = headRevision;
|
|
650
|
+
for (let read = 0; revision && read < VAULT_LINEAGE_MAX_REVISIONS; read++) {
|
|
651
|
+
const record = await store.getWithMetadata(vaultRevisionKey(workspaceId, revision, path));
|
|
652
|
+
const metadata = record.metadata;
|
|
653
|
+
if (!metadata || metadata.schema !== VAULT_REVISION_SCHEMA || metadata.path !== path) return null;
|
|
654
|
+
if (metadata.outcome === "committed" && !metadata.deleted) {
|
|
655
|
+
if (!options.matchesContent && metadata.contentHash === contentHash) return revision;
|
|
656
|
+
if (options.matchesContent && typeof record.value === "string" && await sha256Hex(record.value) === metadata.contentHash && await options.matchesContent(record.value)) return revision;
|
|
657
|
+
}
|
|
658
|
+
revision = metadata.parentRevision;
|
|
659
|
+
}
|
|
660
|
+
return null;
|
|
661
|
+
}
|
|
662
|
+
async function listVaultFileRevisions(workspaceId, path, limit = VAULT_HISTORY_MAX_REVISIONS) {
|
|
663
|
+
validateVaultFilePath(path);
|
|
664
|
+
validateWorkspaceId(workspaceId);
|
|
665
|
+
const head = await readVaultFileState(workspaceId, path);
|
|
666
|
+
if (head.deleted || !head.revision) return [];
|
|
667
|
+
const store = getVaultKV();
|
|
668
|
+
const versions = [];
|
|
669
|
+
let revision = head.revision;
|
|
670
|
+
for (let read = 0; revision && versions.length < limit && read < VAULT_LINEAGE_MAX_REVISIONS; read++) {
|
|
671
|
+
const record = await store.getWithMetadata(vaultRevisionKey(workspaceId, revision, path));
|
|
672
|
+
const metadata = revisionRecordFor(record.metadata, workspaceId, path);
|
|
673
|
+
if (!metadata) {
|
|
674
|
+
if (read === 0 && head.metadata) {
|
|
675
|
+
versions.push({ revision, createdAt: head.metadata.updatedAt, writer: head.metadata.writer, current: true });
|
|
676
|
+
}
|
|
677
|
+
break;
|
|
678
|
+
}
|
|
679
|
+
if (metadata.outcome === "committed" && !metadata.deleted) {
|
|
680
|
+
versions.push({ revision, createdAt: metadata.createdAt, writer: metadata.writer, current: read === 0 });
|
|
681
|
+
}
|
|
682
|
+
revision = metadata.parentRevision;
|
|
683
|
+
}
|
|
684
|
+
return versions;
|
|
685
|
+
}
|
|
686
|
+
async function listCommittedVaultRevisionsPage(workspaceId, options) {
|
|
687
|
+
validateWorkspaceId(workspaceId);
|
|
688
|
+
const store = getVaultKV();
|
|
689
|
+
const page = await store.list({ prefix: vaultRevisionPrefix(workspaceId), limit: options.limit ?? 1e3, cursor: options.cursor });
|
|
690
|
+
if (!page.list_complete && !page.cursor) throw new Error("Vault revision listing did not provide a cursor");
|
|
691
|
+
let metadataComplete = true;
|
|
692
|
+
const candidates = page.keys.flatMap((key) => {
|
|
693
|
+
const record = key.metadata;
|
|
694
|
+
if (!record || record.schema !== VAULT_REVISION_SCHEMA) metadataComplete = false;
|
|
695
|
+
return record?.schema === VAULT_REVISION_SCHEMA && record.workspaceId === workspaceId && record.outcome === "committed" && !record.deleted && options.includePath(record.path) ? [record] : [];
|
|
696
|
+
});
|
|
697
|
+
const operations = /* @__PURE__ */ new Map();
|
|
698
|
+
const committed = await Promise.all(candidates.map(async (record) => {
|
|
699
|
+
if (!record.batchOperation) return record;
|
|
700
|
+
let operation = operations.get(record.operationId);
|
|
701
|
+
if (!operation) {
|
|
702
|
+
operation = vaultOperationCommitted(store, workspaceId, record.operationId, record.path);
|
|
703
|
+
operations.set(record.operationId, operation);
|
|
704
|
+
}
|
|
705
|
+
if (await operation) return record;
|
|
706
|
+
metadataComplete = false;
|
|
707
|
+
return null;
|
|
708
|
+
}));
|
|
709
|
+
const revisions = committed.filter((record) => record !== null);
|
|
710
|
+
return { revisions, complete: page.list_complete, metadataComplete, cursor: page.list_complete ? null : page.cursor ?? null };
|
|
711
|
+
}
|
|
712
|
+
async function readVaultRevisionMetadata(workspaceId, path, revision) {
|
|
713
|
+
validateVaultFilePath(path);
|
|
714
|
+
validateWorkspaceId(workspaceId);
|
|
715
|
+
if (!VAULT_REVISION_ID.test(revision)) return null;
|
|
716
|
+
const key = vaultRevisionKey(workspaceId, revision, path);
|
|
717
|
+
const store = getVaultKV();
|
|
718
|
+
const page = await store.list({ prefix: key, limit: 2 });
|
|
719
|
+
const entry = page.keys[0];
|
|
720
|
+
if (!page.list_complete || page.keys.length !== 1 || !entry || entry.name !== key) return null;
|
|
721
|
+
const metadata = revisionRecordFor("metadata" in entry ? entry.metadata : void 0, workspaceId, path);
|
|
722
|
+
if (!metadata || metadata.revision !== revision || metadata.outcome !== "committed" || metadata.deleted || !/^[a-f0-9]{64}$/.test(metadata.contentHash ?? "") || !metadata.operationId || metadata.contentBytes !== void 0 && (!Number.isSafeInteger(metadata.contentBytes) || metadata.contentBytes < 0)) return null;
|
|
723
|
+
if (metadata.batchOperation && !await vaultOperationCommitted(store, workspaceId, metadata.operationId)) return null;
|
|
724
|
+
return metadata;
|
|
725
|
+
}
|
|
726
|
+
async function readVaultFileRevision(workspaceId, path, revision, options = {}) {
|
|
727
|
+
validateVaultFilePath(path);
|
|
728
|
+
validateWorkspaceId(workspaceId);
|
|
729
|
+
if (!VAULT_REVISION_ID.test(revision)) return null;
|
|
730
|
+
const maxBytes = options.maxBytes;
|
|
731
|
+
if (maxBytes !== void 0 && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) return null;
|
|
732
|
+
const proof = maxBytes !== void 0 ? await readVaultRevisionMetadata(workspaceId, path, revision) : null;
|
|
733
|
+
if (maxBytes !== void 0 && (!proof || proof.contentBytes === void 0 || proof.contentBytes > maxBytes)) return null;
|
|
734
|
+
const record = await getVaultKV().getWithMetadata(vaultRevisionKey(workspaceId, revision, path));
|
|
735
|
+
const metadata = revisionRecordFor(record.metadata, workspaceId, path);
|
|
736
|
+
if (!metadata || metadata.outcome !== "committed" || metadata.deleted || typeof record.value !== "string") return null;
|
|
737
|
+
if (proof && (metadata.revision !== revision || metadata.contentHash !== proof.contentHash || metadata.contentBytes !== proof.contentBytes || new TextEncoder().encode(record.value).byteLength !== proof.contentBytes || await sha256Hex(record.value) !== proof.contentHash)) return null;
|
|
738
|
+
return record.value;
|
|
739
|
+
}
|
|
740
|
+
async function eraseVaultConflictRecords(workspaceId, conflicts) {
|
|
741
|
+
validateWorkspaceId(workspaceId);
|
|
742
|
+
const store = getVaultKV();
|
|
743
|
+
await Promise.all(conflicts.map(({ path, conflictRevision }) => store.delete(vaultRevisionKey(workspaceId, conflictRevision, path))));
|
|
744
|
+
}
|
|
745
|
+
async function purgeHiddenVaultFiles(workspaceId) {
|
|
746
|
+
validateWorkspaceId(workspaceId);
|
|
747
|
+
const store = getVaultKV();
|
|
748
|
+
const markerKey = vaultMetaKey(workspaceId, HIDDEN_VAULT_PURGE_MARKER);
|
|
749
|
+
if (await store.get(markerKey)) return 0;
|
|
750
|
+
const prefix = vaultHeadPrefix(workspaceId);
|
|
751
|
+
let deleted = 0;
|
|
752
|
+
let cursor;
|
|
753
|
+
do {
|
|
754
|
+
const list = await store.list({ prefix, cursor });
|
|
755
|
+
await Promise.all(list.keys.map(async (key) => {
|
|
756
|
+
const path = key.name.slice(prefix.length);
|
|
757
|
+
if (!isHiddenVaultFilePath(path)) return;
|
|
758
|
+
await store.delete(key.name);
|
|
759
|
+
deleted += 1;
|
|
760
|
+
}));
|
|
761
|
+
if (list.list_complete) {
|
|
762
|
+
cursor = void 0;
|
|
763
|
+
} else if (list.cursor) {
|
|
764
|
+
cursor = list.cursor;
|
|
765
|
+
} else {
|
|
766
|
+
throw new Error(`Vault KV listing did not provide a cursor for ${workspaceId}`);
|
|
767
|
+
}
|
|
768
|
+
} while (cursor);
|
|
769
|
+
await store.put(markerKey, (/* @__PURE__ */ new Date()).toISOString());
|
|
770
|
+
return deleted;
|
|
771
|
+
}
|
|
772
|
+
return {
|
|
773
|
+
findVaultRevisionWithContent,
|
|
774
|
+
listVaultFileRevisions,
|
|
775
|
+
listCommittedVaultRevisionsPage,
|
|
776
|
+
readVaultRevisionMetadata,
|
|
777
|
+
readVaultFileRevision,
|
|
778
|
+
eraseVaultConflictRecords,
|
|
779
|
+
purgeHiddenVaultFiles
|
|
780
|
+
};
|
|
781
|
+
}
|
|
782
|
+
function createVaultStore(config) {
|
|
783
|
+
const runtime = createVaultRuntime(config);
|
|
784
|
+
return { ...runtime, ...createVaultFiles(runtime, config), ...createVaultHistory(runtime) };
|
|
785
|
+
}
|
|
786
|
+
|
|
787
|
+
// src/vault/store/coordinator.ts
|
|
788
|
+
var VAULT_FENCE_STORAGE_PREFIX = "vaultFence:";
|
|
789
|
+
function vaultCoordinatorJson(body, status = 200) {
|
|
790
|
+
return new Response(JSON.stringify(body), {
|
|
791
|
+
status,
|
|
792
|
+
headers: { "Content-Type": "application/json" }
|
|
793
|
+
});
|
|
794
|
+
}
|
|
795
|
+
function vaultConvergenceResponse(error) {
|
|
796
|
+
return vaultCoordinatorJson({
|
|
797
|
+
error: {
|
|
798
|
+
code: error.code,
|
|
799
|
+
message: error.message,
|
|
800
|
+
retryable: error.retryable,
|
|
801
|
+
workspaceId: error.workspaceId,
|
|
802
|
+
path: error.path,
|
|
803
|
+
expectedRevision: error.expectedRevision
|
|
804
|
+
}
|
|
805
|
+
}, 503);
|
|
806
|
+
}
|
|
807
|
+
function vaultPathErrorResponse(error) {
|
|
808
|
+
return vaultCoordinatorJson(vaultPathErrorResponseBody(error), 400);
|
|
809
|
+
}
|
|
810
|
+
function nonEmptyString(value) {
|
|
811
|
+
return typeof value === "string" && value.trim() ? value.trim() : null;
|
|
812
|
+
}
|
|
813
|
+
function createVaultCoordinator(options) {
|
|
814
|
+
const { storage, kv } = options;
|
|
815
|
+
let mutationQueue = Promise.resolve();
|
|
816
|
+
function exclusive(work) {
|
|
817
|
+
const run = mutationQueue.catch(() => void 0).then(work);
|
|
818
|
+
mutationQueue = run.then(() => void 0, () => void 0);
|
|
819
|
+
return run;
|
|
820
|
+
}
|
|
821
|
+
async function settled() {
|
|
822
|
+
await mutationQueue.catch(() => void 0);
|
|
823
|
+
}
|
|
824
|
+
function fenceKey(path) {
|
|
825
|
+
return `${VAULT_FENCE_STORAGE_PREFIX}${encodeURIComponent(path)}`;
|
|
826
|
+
}
|
|
827
|
+
async function readVaultFence(path) {
|
|
828
|
+
const fence = await storage.get(fenceKey(path));
|
|
829
|
+
if (!fence) return null;
|
|
830
|
+
if (fence.schema !== "vault-visibility-fence-v1" || fence.path !== path) {
|
|
831
|
+
throw new Error(`Invalid Vault visibility fence for ${path}`);
|
|
832
|
+
}
|
|
833
|
+
return fence;
|
|
834
|
+
}
|
|
835
|
+
async function writeVaultFence(fence) {
|
|
836
|
+
await storage.put(fenceKey(fence.path), fence);
|
|
837
|
+
}
|
|
838
|
+
async function observeVaultFence(fence, surface) {
|
|
839
|
+
const current = await readVaultFence(fence.path);
|
|
840
|
+
if (!current || current.revision !== fence.revision || current.operationId !== fence.operationId) return;
|
|
841
|
+
const observed = {
|
|
842
|
+
...current,
|
|
843
|
+
headVisible: current.headVisible || surface === "head",
|
|
844
|
+
listVisible: current.listVisible || surface === "list"
|
|
845
|
+
};
|
|
846
|
+
if (observed.headVisible && observed.listVisible) {
|
|
847
|
+
await storage.delete(fenceKey(fence.path));
|
|
848
|
+
} else {
|
|
849
|
+
await writeVaultFence(observed);
|
|
850
|
+
}
|
|
851
|
+
}
|
|
852
|
+
async function listVaultFences() {
|
|
853
|
+
const stored = await storage.list({ prefix: VAULT_FENCE_STORAGE_PREFIX });
|
|
854
|
+
const fences = [];
|
|
855
|
+
for (const value of stored.values()) {
|
|
856
|
+
if (value.schema !== "vault-visibility-fence-v1" || !value.path || !value.revision) {
|
|
857
|
+
throw new Error("Invalid persisted Vault visibility fence");
|
|
858
|
+
}
|
|
859
|
+
fences.push(value);
|
|
860
|
+
}
|
|
861
|
+
return fences;
|
|
862
|
+
}
|
|
863
|
+
async function readVaultHeadFenced(workspaceId, path) {
|
|
864
|
+
const fence = await readVaultFence(path);
|
|
865
|
+
if (!fence) return readVaultHeadState(kv, workspaceId, path);
|
|
866
|
+
const state = await readVaultHeadStateConverged(kv, workspaceId, path, fence);
|
|
867
|
+
await observeVaultFence(fence, "head");
|
|
868
|
+
return state;
|
|
869
|
+
}
|
|
870
|
+
async function handleVaultHeadGet(request) {
|
|
871
|
+
const body = await request.json().catch(() => null);
|
|
872
|
+
const workspaceId = nonEmptyString(body?.workspaceId);
|
|
873
|
+
const path = nonEmptyString(body?.path);
|
|
874
|
+
if (!workspaceId || !path) return vaultCoordinatorJson({ error: "Missing workspaceId or path" }, 400);
|
|
875
|
+
try {
|
|
876
|
+
validateWorkspaceId(workspaceId);
|
|
877
|
+
validateVaultFilePath(path);
|
|
878
|
+
await settled();
|
|
879
|
+
return vaultCoordinatorJson({ state: await readVaultHeadFenced(workspaceId, path) });
|
|
880
|
+
} catch (error) {
|
|
881
|
+
if (error instanceof VaultReadConvergenceError) return vaultConvergenceResponse(error);
|
|
882
|
+
if (error instanceof VaultPathError) return vaultPathErrorResponse(error);
|
|
883
|
+
throw error;
|
|
884
|
+
}
|
|
885
|
+
}
|
|
886
|
+
async function handleVaultHeadList(request) {
|
|
887
|
+
const body = await request.json().catch(() => null);
|
|
888
|
+
const workspaceId = nonEmptyString(body?.workspaceId);
|
|
889
|
+
const cursor = body?.cursor === void 0 || body.cursor === null ? void 0 : nonEmptyString(body.cursor);
|
|
890
|
+
const limit = body?.limit === void 0 ? void 0 : Number(body.limit);
|
|
891
|
+
const pathPrefix = body?.prefix === void 0 ? "" : body.prefix;
|
|
892
|
+
if (!workspaceId || body?.cursor !== void 0 && body.cursor !== null && !cursor || limit !== void 0 && (!Number.isInteger(limit) || limit < 1 || limit > 1e3) || typeof pathPrefix !== "string") {
|
|
893
|
+
return vaultCoordinatorJson({ error: "Invalid Vault head list request" }, 400);
|
|
894
|
+
}
|
|
895
|
+
try {
|
|
896
|
+
validateWorkspaceId(workspaceId);
|
|
897
|
+
await settled();
|
|
898
|
+
const prefix = vaultHeadPrefix(workspaceId);
|
|
899
|
+
const listPrefix = vaultHeadPathPrefix(workspaceId, pathPrefix);
|
|
900
|
+
const [listed, allFences] = await Promise.all([
|
|
901
|
+
kv.list({ prefix: listPrefix, cursor: cursor ?? void 0, ...limit === void 0 ? {} : { limit } }),
|
|
902
|
+
listVaultFences()
|
|
903
|
+
]);
|
|
904
|
+
if (!listed.list_complete && !listed.cursor) {
|
|
905
|
+
throw new Error(`Vault KV listing did not provide a cursor for ${workspaceId}`);
|
|
906
|
+
}
|
|
907
|
+
const fences = allFences.filter((fence) => fence.path.startsWith(pathPrefix) && isWorkspaceFileExportable(fence.path));
|
|
908
|
+
const fencesByPath = new Map(fences.map((fence) => [fence.path, fence]));
|
|
909
|
+
const entries = /* @__PURE__ */ new Map();
|
|
910
|
+
const listVisible = [];
|
|
911
|
+
for (const key of listed.keys) {
|
|
912
|
+
const path = key.name.slice(prefix.length);
|
|
913
|
+
if (!isWorkspaceFileExportable(path)) continue;
|
|
914
|
+
validateVaultFilePath(path);
|
|
915
|
+
const fence = fencesByPath.get(path);
|
|
916
|
+
const metadata = parseVaultHeadMetadata(key.metadata);
|
|
917
|
+
if (fence) {
|
|
918
|
+
entries.set(path, { path, revision: fence.revision, contentHash: fence.contentHash, deleted: fence.deleted });
|
|
919
|
+
if (metadata && vaultHeadMatchesFence({
|
|
920
|
+
revision: metadata.revision,
|
|
921
|
+
contentHash: metadata.contentHash,
|
|
922
|
+
deleted: metadata.deleted,
|
|
923
|
+
metadata
|
|
924
|
+
}, fence)) listVisible.push(fence);
|
|
925
|
+
continue;
|
|
926
|
+
}
|
|
927
|
+
if (metadata && !metadata.batchOperation) {
|
|
928
|
+
entries.set(path, { path, revision: metadata.revision, contentHash: metadata.contentHash, deleted: metadata.deleted });
|
|
929
|
+
continue;
|
|
930
|
+
}
|
|
931
|
+
const state = await readVaultHeadState(kv, workspaceId, path);
|
|
932
|
+
entries.set(path, { path, revision: state.revision, contentHash: state.contentHash, deleted: state.deleted });
|
|
933
|
+
}
|
|
934
|
+
if (!cursor) {
|
|
935
|
+
for (const fence of fences) {
|
|
936
|
+
if (fence.deleted || entries.has(fence.path)) continue;
|
|
937
|
+
entries.set(fence.path, { path: fence.path, revision: fence.revision, contentHash: fence.contentHash, deleted: false });
|
|
938
|
+
}
|
|
939
|
+
}
|
|
940
|
+
for (const fence of listVisible) await observeVaultFence(fence, "list");
|
|
941
|
+
options.onHeadList?.({
|
|
942
|
+
workspaceId,
|
|
943
|
+
fences: fences.length,
|
|
944
|
+
headKeys: listed.keys.length,
|
|
945
|
+
entries: entries.size,
|
|
946
|
+
paged: Boolean(cursor)
|
|
947
|
+
});
|
|
948
|
+
return vaultCoordinatorJson({
|
|
949
|
+
entries: [...entries.values()].sort((left, right) => left.path.localeCompare(right.path)),
|
|
950
|
+
complete: listed.list_complete,
|
|
951
|
+
cursor: listed.list_complete ? null : listed.cursor
|
|
952
|
+
});
|
|
953
|
+
} catch (error) {
|
|
954
|
+
if (error instanceof VaultReadConvergenceError) return vaultConvergenceResponse(error);
|
|
955
|
+
if (error instanceof VaultPathError) return vaultPathErrorResponse(error);
|
|
956
|
+
throw error;
|
|
957
|
+
}
|
|
958
|
+
}
|
|
959
|
+
async function handleVaultMutation(request) {
|
|
960
|
+
const body = await request.json().catch(() => null);
|
|
961
|
+
if (!body || typeof body.workspaceId !== "string" || typeof body.operationId !== "string" || !body.writer || !Array.isArray(body.changes)) {
|
|
962
|
+
return vaultCoordinatorJson({ error: "Invalid Vault mutation request" }, 400);
|
|
963
|
+
}
|
|
964
|
+
const apply = async () => {
|
|
965
|
+
const outcome = await applyVaultMutationBatch(
|
|
966
|
+
kv,
|
|
967
|
+
body,
|
|
968
|
+
(workspaceId, path) => readVaultHeadFenced(workspaceId, path),
|
|
969
|
+
options.mutationPolicy
|
|
970
|
+
);
|
|
971
|
+
if (outcome.status === "applied") {
|
|
972
|
+
const committedAt = (/* @__PURE__ */ new Date()).toISOString();
|
|
973
|
+
await Promise.all(outcome.files.map((file) => writeVaultFence({
|
|
974
|
+
schema: "vault-visibility-fence-v1",
|
|
975
|
+
path: file.path,
|
|
976
|
+
revision: file.revision,
|
|
977
|
+
contentHash: file.contentHash,
|
|
978
|
+
deleted: file.deleted,
|
|
979
|
+
operationId: body.operationId,
|
|
980
|
+
headVisible: false,
|
|
981
|
+
listVisible: false,
|
|
982
|
+
committedAt
|
|
983
|
+
})));
|
|
984
|
+
}
|
|
985
|
+
return outcome;
|
|
986
|
+
};
|
|
987
|
+
try {
|
|
988
|
+
const outcome = await exclusive(() => options.aroundMutation ? options.aroundMutation(body, apply) : apply());
|
|
989
|
+
return vaultCoordinatorJson(outcome, outcome.status === "conflict" ? 409 : 200);
|
|
990
|
+
} catch (error) {
|
|
991
|
+
if (error instanceof VaultReadConvergenceError) return vaultConvergenceResponse(error);
|
|
992
|
+
if (error instanceof VaultPathError) return vaultPathErrorResponse(error);
|
|
993
|
+
return vaultCoordinatorJson({ error: error instanceof Error ? error.message : "Vault mutation failed" }, 500);
|
|
994
|
+
}
|
|
995
|
+
}
|
|
996
|
+
return {
|
|
997
|
+
exclusive,
|
|
998
|
+
settled,
|
|
999
|
+
readVaultFence,
|
|
1000
|
+
observeVaultFence,
|
|
1001
|
+
readVaultHeadFenced,
|
|
1002
|
+
handleVaultHeadGet,
|
|
1003
|
+
handleVaultHeadList,
|
|
1004
|
+
handleVaultMutation
|
|
1005
|
+
};
|
|
1006
|
+
}
|
|
1007
|
+
|
|
1008
|
+
// src/vault/store/sandbox-sync.ts
|
|
1009
|
+
var VAULT_SANDBOX_BASELINE_SCHEMA = "vault-sandbox-baseline-v3";
|
|
1010
|
+
var VAULT_SANDBOX_BASELINE_V2_SCHEMA = "vault-sandbox-baseline-v2";
|
|
1011
|
+
var VAULT_SANDBOX_BASELINE_V1_SCHEMA = "vault-sandbox-baseline-v1";
|
|
1012
|
+
function normalizeVaultSandboxBaseline(stored) {
|
|
1013
|
+
if (!stored) return { baseline: null, legacy: false };
|
|
1014
|
+
stored = { ...stored, files: Object.fromEntries(Object.entries(stored.files).filter(([path]) => isWorkspaceFileExportable(path))) };
|
|
1015
|
+
const schema = stored.schema;
|
|
1016
|
+
if (schema === VAULT_SANDBOX_BASELINE_SCHEMA) return { baseline: stored, legacy: false };
|
|
1017
|
+
if (schema === VAULT_SANDBOX_BASELINE_V2_SCHEMA) return { baseline: stored, legacy: true };
|
|
1018
|
+
if (schema === VAULT_SANDBOX_BASELINE_V1_SCHEMA) {
|
|
1019
|
+
const { progress: _progress, ...rest } = stored;
|
|
1020
|
+
return { baseline: { ...rest, schema: VAULT_SANDBOX_BASELINE_V2_SCHEMA }, legacy: true };
|
|
1021
|
+
}
|
|
1022
|
+
return { baseline: null, legacy: false };
|
|
1023
|
+
}
|
|
1024
|
+
function sandboxVaultRejection(path, stage, code, error) {
|
|
1025
|
+
return {
|
|
1026
|
+
path,
|
|
1027
|
+
stage,
|
|
1028
|
+
code,
|
|
1029
|
+
message: error instanceof Error ? error.message : String(error)
|
|
1030
|
+
};
|
|
1031
|
+
}
|
|
1032
|
+
var VaultHydrationError = class extends Error {
|
|
1033
|
+
code = "vault.hydration_failed";
|
|
1034
|
+
constructor(message, cause) {
|
|
1035
|
+
super(message, { cause });
|
|
1036
|
+
this.name = "VaultHydrationError";
|
|
1037
|
+
}
|
|
1038
|
+
};
|
|
1039
|
+
var VaultHydrationIncompleteError = class extends Error {
|
|
1040
|
+
code = "vault.hydration_incomplete";
|
|
1041
|
+
retryable = true;
|
|
1042
|
+
progress;
|
|
1043
|
+
constructor(progress, detail) {
|
|
1044
|
+
super(`Vault hydration is incomplete (${progress.processedPaths} heads processed)${detail ? `: ${detail}` : ""}`);
|
|
1045
|
+
this.name = "VaultHydrationIncompleteError";
|
|
1046
|
+
this.progress = progress;
|
|
1047
|
+
}
|
|
1048
|
+
};
|
|
1049
|
+
var VaultFilesystemIncarnationError = class extends Error {
|
|
1050
|
+
code;
|
|
1051
|
+
retryable = true;
|
|
1052
|
+
constructor(code, message) {
|
|
1053
|
+
super(message);
|
|
1054
|
+
this.name = "VaultFilesystemIncarnationError";
|
|
1055
|
+
this.code = code;
|
|
1056
|
+
}
|
|
1057
|
+
};
|
|
1058
|
+
function readReadySandboxFilesystemIncarnation(box) {
|
|
1059
|
+
const candidate = box;
|
|
1060
|
+
const comparison = compareIncarnationBaseline(void 0, candidate);
|
|
1061
|
+
if (comparison.verdict === "unidentified") {
|
|
1062
|
+
return {
|
|
1063
|
+
succeeded: false,
|
|
1064
|
+
error: new VaultFilesystemIncarnationError(
|
|
1065
|
+
"vault.filesystem_incarnation_missing",
|
|
1066
|
+
"Sandbox filesystem incarnation identity is unavailable"
|
|
1067
|
+
)
|
|
1068
|
+
};
|
|
1069
|
+
}
|
|
1070
|
+
if (comparison.verdict === "not-ready") {
|
|
1071
|
+
return {
|
|
1072
|
+
succeeded: false,
|
|
1073
|
+
error: new VaultFilesystemIncarnationError(
|
|
1074
|
+
"vault.filesystem_incarnation_not_ready",
|
|
1075
|
+
`Sandbox filesystem incarnation ${candidate.filesystemIncarnationId} is ${String(comparison.readiness ?? "not ready")}`
|
|
1076
|
+
)
|
|
1077
|
+
};
|
|
1078
|
+
}
|
|
1079
|
+
if (comparison.verdict !== "no-baseline") {
|
|
1080
|
+
throw new Error(`Unexpected filesystem incarnation comparison verdict: ${comparison.verdict}`);
|
|
1081
|
+
}
|
|
1082
|
+
return {
|
|
1083
|
+
succeeded: true,
|
|
1084
|
+
value: {
|
|
1085
|
+
id: candidate.filesystemIncarnationId,
|
|
1086
|
+
provenance: candidate.filesystemIncarnationProvenance
|
|
1087
|
+
}
|
|
1088
|
+
};
|
|
1089
|
+
}
|
|
1090
|
+
function buildSandboxVaultRenameUnits(items, describe, orderedItems = items) {
|
|
1091
|
+
const putsByHash = /* @__PURE__ */ new Map();
|
|
1092
|
+
for (const item of items) {
|
|
1093
|
+
const candidate = describe(item);
|
|
1094
|
+
if (candidate.kind !== "put" || candidate.contentHash === null) continue;
|
|
1095
|
+
const puts = putsByHash.get(candidate.contentHash) ?? [];
|
|
1096
|
+
puts.push(item);
|
|
1097
|
+
putsByHash.set(candidate.contentHash, puts);
|
|
1098
|
+
}
|
|
1099
|
+
const paired = /* @__PURE__ */ new Set();
|
|
1100
|
+
const units = [];
|
|
1101
|
+
for (const deletion of orderedItems) {
|
|
1102
|
+
const candidate = describe(deletion);
|
|
1103
|
+
if (candidate.kind !== "delete" || candidate.contentHash === null) continue;
|
|
1104
|
+
const destination = putsByHash.get(candidate.contentHash)?.find((put) => !paired.has(put));
|
|
1105
|
+
if (!destination) continue;
|
|
1106
|
+
paired.add(deletion);
|
|
1107
|
+
paired.add(destination);
|
|
1108
|
+
units.push([deletion, destination].sort((left, right) => describe(left).path.localeCompare(describe(right).path)));
|
|
1109
|
+
}
|
|
1110
|
+
for (const item of orderedItems) if (!paired.has(item)) units.push([item]);
|
|
1111
|
+
units.sort((left, right) => describe(left[0]).path.localeCompare(describe(right[0]).path));
|
|
1112
|
+
return units;
|
|
1113
|
+
}
|
|
1114
|
+
function groupSandboxVaultChanges(changes, groupSize) {
|
|
1115
|
+
const units = buildSandboxVaultRenameUnits(changes, (change) => change);
|
|
1116
|
+
const groups = [];
|
|
1117
|
+
let current = [];
|
|
1118
|
+
for (const unit of units) {
|
|
1119
|
+
if (current.length > 0 && current.length + unit.length > groupSize) {
|
|
1120
|
+
groups.push(current);
|
|
1121
|
+
current = [];
|
|
1122
|
+
}
|
|
1123
|
+
current.push(...unit);
|
|
1124
|
+
}
|
|
1125
|
+
if (current.length > 0) groups.push(current);
|
|
1126
|
+
return groups;
|
|
1127
|
+
}
|
|
1128
|
+
async function mapWithConcurrency(values, concurrency, mapper) {
|
|
1129
|
+
const results = new Array(values.length);
|
|
1130
|
+
let nextIndex = 0;
|
|
1131
|
+
const workers = Array.from({ length: Math.min(concurrency, values.length) }, async () => {
|
|
1132
|
+
while (nextIndex < values.length) {
|
|
1133
|
+
const index = nextIndex;
|
|
1134
|
+
nextIndex += 1;
|
|
1135
|
+
results[index] = await mapper(values[index]);
|
|
1136
|
+
}
|
|
1137
|
+
});
|
|
1138
|
+
await Promise.all(workers);
|
|
1139
|
+
return results;
|
|
1140
|
+
}
|
|
1141
|
+
export {
|
|
1142
|
+
VAULT_HEAD_SCHEMA,
|
|
1143
|
+
VAULT_HISTORY_MAX_REVISIONS,
|
|
1144
|
+
VAULT_KV_KEY_MAX_BYTES,
|
|
1145
|
+
VAULT_LINEAGE_MAX_REVISIONS,
|
|
1146
|
+
VAULT_OPERATION_SCHEMA,
|
|
1147
|
+
VAULT_READ_CONVERGENCE_INITIAL_DELAY_MS,
|
|
1148
|
+
VAULT_READ_CONVERGENCE_MAX_DELAY_MS,
|
|
1149
|
+
VAULT_READ_CONVERGENCE_TIMEOUT_MS,
|
|
1150
|
+
VAULT_REVISION_SCHEMA,
|
|
1151
|
+
VAULT_SANDBOX_BASELINE_SCHEMA,
|
|
1152
|
+
VaultConflictError,
|
|
1153
|
+
VaultFileNotFoundError,
|
|
1154
|
+
VaultFilesystemIncarnationError,
|
|
1155
|
+
VaultHydrationError,
|
|
1156
|
+
VaultHydrationIncompleteError,
|
|
1157
|
+
VaultPathError,
|
|
1158
|
+
VaultPrivateRuntimeFileError,
|
|
1159
|
+
VaultReadConvergenceError,
|
|
1160
|
+
VaultStorageKeyError,
|
|
1161
|
+
applyVaultMutationBatch,
|
|
1162
|
+
buildSandboxVaultRenameUnits,
|
|
1163
|
+
buildTreeFromPaths,
|
|
1164
|
+
createVaultCoordinator,
|
|
1165
|
+
createVaultStore,
|
|
1166
|
+
flattenVaultTreePaths,
|
|
1167
|
+
groupSandboxVaultChanges,
|
|
1168
|
+
isHiddenVaultFilePath,
|
|
1169
|
+
mapWithConcurrency,
|
|
1170
|
+
normalizeVaultSandboxBaseline,
|
|
1171
|
+
normalizeVaultWriterProvenance,
|
|
1172
|
+
parseVaultHeadMetadata,
|
|
1173
|
+
parseVaultPathErrorResponse,
|
|
1174
|
+
readReadySandboxFilesystemIncarnation,
|
|
1175
|
+
readVaultHeadState,
|
|
1176
|
+
readVaultHeadStateConverged,
|
|
1177
|
+
readVaultHeadStateForErasure,
|
|
1178
|
+
sandboxVaultRejection,
|
|
1179
|
+
validateVaultFilePath,
|
|
1180
|
+
validateVaultMutationKeys,
|
|
1181
|
+
validateWorkspaceId,
|
|
1182
|
+
vaultConvergenceResponse,
|
|
1183
|
+
vaultCoordinatorJson,
|
|
1184
|
+
vaultErasureJobKey,
|
|
1185
|
+
vaultErasureKey,
|
|
1186
|
+
vaultErasurePrefix,
|
|
1187
|
+
vaultHeadCreation,
|
|
1188
|
+
vaultHeadKey,
|
|
1189
|
+
vaultHeadMatchesFence,
|
|
1190
|
+
vaultHeadPathPrefix,
|
|
1191
|
+
vaultHeadPrefix,
|
|
1192
|
+
vaultHeadSequence,
|
|
1193
|
+
vaultMetaKey,
|
|
1194
|
+
vaultOperationCommitted,
|
|
1195
|
+
vaultOperationKey,
|
|
1196
|
+
vaultPathErrorResponse,
|
|
1197
|
+
vaultPathErrorResponseBody,
|
|
1198
|
+
vaultRevisionKey,
|
|
1199
|
+
vaultRevisionPrefix,
|
|
1200
|
+
vaultWriterActor
|
|
1201
|
+
};
|
|
1202
|
+
//# sourceMappingURL=index.js.map
|