@ultrst-armada/kloks 2.0.3 → 2.0.5

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.
Files changed (81) hide show
  1. package/package.json +6 -1
  2. package/packages/backend/dist/api/index.js +2 -1
  3. package/packages/backend/dist/{chunk-5F5V7NAG.js → chunk-5Y7K7HAT.js} +4 -1
  4. package/packages/backend/dist/{chunk-SQKG3S6P.js → chunk-AUNIGE6Q.js} +2 -2
  5. package/packages/backend/dist/chunk-BRNWUIH5.js +197 -0
  6. package/packages/backend/dist/{chunk-NY2SQOXI.js → chunk-CDRHYO44.js} +4 -1
  7. package/packages/backend/dist/{chunk-ZBNSK26X.js → chunk-CV55JMT7.js} +6 -5
  8. package/packages/backend/dist/{chunk-OWMQLML7.js → chunk-EMSSTOOK.js} +33 -2
  9. package/packages/backend/dist/chunk-FSOOAU6G.js +1132 -0
  10. package/packages/backend/dist/chunk-GVMVYC6C.js +0 -0
  11. package/packages/backend/dist/chunk-I6T64MLT.js +171 -0
  12. package/packages/backend/dist/chunk-ICVDGH2I.js +889 -0
  13. package/packages/backend/dist/chunk-IP6XWQU2.js +48 -0
  14. package/packages/backend/dist/chunk-IRNQXVYA.js +746 -0
  15. package/packages/backend/dist/{chunk-POLVHTHJ.js → chunk-KCPQWJBO.js} +4 -1
  16. package/packages/backend/dist/chunk-LC6ULEM2.js +125 -0
  17. package/packages/backend/dist/{chunk-NTKUQVCQ.js → chunk-LMUMMVTU.js} +14 -2
  18. package/packages/backend/dist/chunk-LMY6MGFD.js +78 -0
  19. package/packages/backend/dist/{chunk-OQRQCDS6.js → chunk-TRJVVNO7.js} +2 -2
  20. package/packages/backend/dist/{chunk-KPLDYX5Z.js → chunk-TRP76UR2.js} +33 -26
  21. package/packages/backend/dist/{chunk-FK3OAUXM.js → chunk-WYEVA4RC.js} +4 -2
  22. package/packages/backend/dist/{chunk-Z6G32NQQ.js → chunk-XKUWLO2M.js} +12 -9
  23. package/packages/backend/dist/{chunk-OXEP3AP6.js → chunk-Z2CT2MJ2.js} +158 -1
  24. package/packages/backend/dist/control-plane/index.js +3 -1
  25. package/packages/backend/dist/core/b2DirectCore.test.d.ts +1 -0
  26. package/packages/backend/dist/core/cloudflareIntegrationCore.test.d.ts +1 -0
  27. package/packages/backend/dist/core/googleDriveOAuthCore.d.ts +51 -0
  28. package/packages/backend/dist/core/googleDriveOAuthCore.test.d.ts +1 -0
  29. package/packages/backend/dist/core/index.d.ts +3 -0
  30. package/packages/backend/dist/core/storageConnectionCore.d.ts +136 -0
  31. package/packages/backend/dist/core/storageConnectionCore.test.d.ts +1 -0
  32. package/packages/backend/dist/core/storageConnectionRuntimeCore.d.ts +57 -0
  33. package/packages/backend/dist/core/storageConnectionRuntimeCore.test.d.ts +1 -0
  34. package/packages/backend/dist/core/storageContracts.d.ts +77 -0
  35. package/packages/backend/dist/core/storageProviderRegistry.d.ts +7 -0
  36. package/packages/backend/dist/core/systemCredentialsCore.d.ts +46 -0
  37. package/packages/backend/dist/core/unifiedDb.d.ts +12 -2
  38. package/packages/backend/dist/core/unifiedDb.errors.test.d.ts +1 -0
  39. package/packages/backend/dist/core/unifiedDbNodeAdapter.d.ts +6 -0
  40. package/packages/backend/dist/core/workspaceBucketSyncCore.d.ts +3 -4
  41. package/packages/backend/dist/core/workspaceBucketSyncCore.test.d.ts +1 -0
  42. package/packages/backend/dist/core/workspaceCore.d.ts +25 -6
  43. package/packages/backend/dist/core/workspaceDataCore.test.d.ts +1 -0
  44. package/packages/backend/dist/core/workspaceFileCore.d.ts +25 -7
  45. package/packages/backend/dist/core/workspaceFileCore.test.d.ts +1 -0
  46. package/packages/backend/dist/core/workspaceFileNodeAdapter.d.ts +6 -0
  47. package/packages/backend/dist/core/workspaceStorageDetailsCore.d.ts +4 -8
  48. package/packages/backend/dist/core/workspaceStorageDetailsCore.test.d.ts +1 -0
  49. package/packages/backend/dist/development/index.js +1 -1
  50. package/packages/backend/dist/development/playwrightInspectionService.js +1 -1
  51. package/packages/backend/dist/development/playwrightInspectionSupport.d.ts +1 -0
  52. package/packages/backend/dist/index.js +22 -16
  53. package/packages/backend/dist/krnl-services.d.ts +0 -22
  54. package/packages/backend/dist/krnl-services.js +8 -19
  55. package/packages/backend/dist/krnl-services.node.d.ts +28 -0
  56. package/packages/backend/dist/node.d.ts +3 -0
  57. package/packages/backend/dist/node.js +645 -463
  58. package/packages/backend/dist/resolver/index.js +13 -0
  59. package/packages/backend/dist/resolver/systemDatabaseUrl.d.ts +16 -12
  60. package/packages/backend/dist/services/node.js +12 -10
  61. package/packages/backend/dist/srkl/index.js +6 -4
  62. package/packages/backend/dist/storage/B2DirectClient.d.ts +7 -13
  63. package/packages/backend/dist/storage/B2DirectClient.test.d.ts +1 -0
  64. package/packages/backend/dist/storage/GoogleDriveWorkspaceService.d.ts +5 -0
  65. package/packages/backend/dist/storage/index.js +4 -3
  66. package/packages/backend/dist/storage/node.js +7 -6
  67. package/packages/backend/dist/storage-workspace.js +1 -1
  68. package/packages/backend/dist/workspace/index.js +2 -1
  69. package/packages/backend/dist/workspace/node.js +12 -7
  70. package/packages/backend/dist/workspaceFileCore-UURQPP62.js +28 -0
  71. package/packages/backend/package.json +8 -3
  72. package/packages/services/dist/index.js +8 -2
  73. package/packages/state-graph/dist/browser.js +16 -16
  74. package/packages/state-graph/dist/index.js +16 -16
  75. package/packages/backend/dist/chunk-4QEMALXF.js +0 -90
  76. package/packages/backend/dist/chunk-AOZSDRNY.js +0 -159
  77. package/packages/backend/dist/chunk-GYSZ6CAX.js +0 -19
  78. package/packages/backend/dist/chunk-JCMB7BIM.js +0 -211
  79. package/packages/backend/dist/chunk-JGUWYVOL.js +0 -570
  80. package/packages/backend/dist/chunk-LMOM7CST.js +0 -427
  81. package/packages/state-graph/dist/{chunk-UKTICGGV.js → chunk-YUJC367F.js} +3 -3
@@ -0,0 +1,889 @@
1
+ import {
2
+ getPrimarySrklDeploymentUrl,
3
+ getSrklAccounts,
4
+ srklListBackblazeBuckets
5
+ } from "./chunk-TRP76UR2.js";
6
+ import {
7
+ formatCanonicalWorkspaceFolderName,
8
+ sanitizeWorkspaceName
9
+ } from "./chunk-FZKBTF34.js";
10
+ import {
11
+ createWorkspace,
12
+ deleteWorkspace,
13
+ findUserWorkspace,
14
+ getWorkspaces,
15
+ updateWorkspace
16
+ } from "./chunk-IRNQXVYA.js";
17
+ import {
18
+ deleteWorkspaceFile,
19
+ listWorkspaceFiles,
20
+ readWorkspaceFile,
21
+ writeWorkspaceFile
22
+ } from "./chunk-BRNWUIH5.js";
23
+ import {
24
+ completeGoogleDriveAuthorization,
25
+ createBackblazeStorageConnection,
26
+ deleteGoogleDriveFileForConnection,
27
+ deleteUserStorageConnection,
28
+ getGoogleDriveAccountIdentityForUser,
29
+ getStorageProviderCapabilities,
30
+ getSystemGoogleOAuthConfiguration,
31
+ listBackblazeBucketsForConnection,
32
+ listGoogleDriveFilesForConnection,
33
+ listGoogleDriveFoldersForConnection,
34
+ listUserStorageConnections,
35
+ listUserStorageConnectionsWithSecrets,
36
+ persistGoogleDriveTokens,
37
+ queryUnifiedDb,
38
+ readGoogleDriveFileForConnection,
39
+ resolveUserStorageConnectionSecret,
40
+ resolveUserWorkspaceStorageAssociation,
41
+ selectGoogleDriveRootFolder,
42
+ setPrimaryUserStorageConnection,
43
+ testBackblazeCredentials,
44
+ testGoogleDriveConnectionForUser,
45
+ writeGoogleDriveFileForConnection
46
+ } from "./chunk-FSOOAU6G.js";
47
+ import {
48
+ loginSystemUser,
49
+ resolveUserFromToken
50
+ } from "./chunk-2COYZMUJ.js";
51
+ import {
52
+ b2ListBuckets
53
+ } from "./chunk-I6T64MLT.js";
54
+ import {
55
+ GOOGLE_DRIVE_WORKSPACE_SCOPE,
56
+ GoogleDriveWorkspaceService
57
+ } from "./chunk-EMSSTOOK.js";
58
+
59
+ // src/krnl-services.ts
60
+ import {
61
+ createService,
62
+ createServiceDefinition
63
+ } from "@ultrst-armada/krnl";
64
+
65
+ // src/core/storageConnectionRuntimeCore.ts
66
+ function makeQuery(env) {
67
+ return (sql, params) => queryUnifiedDb(sql, params, env);
68
+ }
69
+ function safeRelativePath(value) {
70
+ const normalized = String(value || "").replace(/\\/g, "/").replace(/^\/+/, "");
71
+ const parts = normalized.split("/");
72
+ if (!normalized || normalized.includes("\0") || parts.some((part) => !part || part === "." || part === "..")) {
73
+ throw new Error("Storage file path must be a safe workspace-relative path.");
74
+ }
75
+ return normalized;
76
+ }
77
+ async function resolveWorkspaceContext(input, query) {
78
+ const userId = String(input.userId || "").trim();
79
+ const connectionId = String(input.connectionId || "").trim();
80
+ if (!userId || !connectionId) {
81
+ throw new Error("A verified user and storage connection ID are required.");
82
+ }
83
+ const connection = await resolveUserStorageConnectionSecret(userId, connectionId, query);
84
+ if (!connection || connection.enabled === false) {
85
+ throw new Error("The selected storage connection is unavailable for this user.");
86
+ }
87
+ const folderPrefix = safeRelativePath(String(input.folderPrefix || "").replace(/^\/+|\/+$/g, ""));
88
+ if (!folderPrefix) throw new Error("Workspace storage folder prefix is required.");
89
+ if (!["backblaze_b2", "google_drive"].includes(String(connection.provider))) {
90
+ throw new Error("Only canonical Backblaze B2 and Google Drive connections are supported by this shared file service.");
91
+ }
92
+ const persistedWorkspace = await resolveUserWorkspaceStorageAssociation(
93
+ userId,
94
+ connectionId,
95
+ folderPrefix,
96
+ query
97
+ );
98
+ if (!persistedWorkspace) {
99
+ throw new Error("The selected workspace is not associated with this owner and storage connection.");
100
+ }
101
+ const workspaceProvider = String(persistedWorkspace.storageProvider || "").toLowerCase();
102
+ if (workspaceProvider !== String(connection.provider).toLowerCase()) {
103
+ throw new Error("The persisted workspace provider does not match the selected storage connection.");
104
+ }
105
+ const savedBucketName = String(
106
+ persistedWorkspace.b2BucketName || persistedWorkspace.bucketName || connection.b2BucketName || connection.bucketName || ""
107
+ ).trim();
108
+ const savedRootFolderId = String(
109
+ persistedWorkspace.googleRootFolderId || connection.googleRootFolderId || ""
110
+ ).trim();
111
+ if (connection.provider === "backblaze_b2") {
112
+ if (!savedBucketName) throw new Error("The selected workspace has no persisted B2 bucket.");
113
+ if (input.bucketName && input.bucketName !== savedBucketName) {
114
+ throw new Error("The requested B2 bucket does not match the persisted workspace association.");
115
+ }
116
+ }
117
+ if (connection.provider === "google_drive") {
118
+ if (!savedRootFolderId) throw new Error("The selected Google Drive connection has no persisted workspace root folder.");
119
+ if (input.rootFolderId && input.rootFolderId !== savedRootFolderId) {
120
+ throw new Error("The requested Google Drive root does not match the persisted workspace association.");
121
+ }
122
+ }
123
+ const workspace = {
124
+ ...persistedWorkspace,
125
+ id: String(persistedWorkspace.id),
126
+ name: String(persistedWorkspace.name || "Workspace"),
127
+ storageProvider: connection.provider,
128
+ storageConnectionId: connection.id,
129
+ localFolderKey: folderPrefix,
130
+ workspacePath: String(persistedWorkspace.workspacePath || "./" + folderPrefix),
131
+ ...connection.provider === "backblaze_b2" ? { b2BucketName: savedBucketName } : {},
132
+ ...connection.provider === "google_drive" ? { googleRootFolderId: savedRootFolderId } : {}
133
+ };
134
+ return {
135
+ workspace,
136
+ connection: {
137
+ ...connection,
138
+ __ownerUserId: userId
139
+ }
140
+ };
141
+ }
142
+ async function writeUserWorkspaceStorageFile(input) {
143
+ const context = await resolveWorkspaceContext(input, makeQuery(input.env));
144
+ await writeWorkspaceFile(
145
+ context.workspace,
146
+ context.connection,
147
+ safeRelativePath(input.relativePath),
148
+ input.content,
149
+ input.contentType || "application/octet-stream",
150
+ input.env
151
+ );
152
+ return { success: true };
153
+ }
154
+ async function readUserWorkspaceStorageFile(input) {
155
+ const context = await resolveWorkspaceContext(input, makeQuery(input.env));
156
+ return readWorkspaceFile(context.workspace, context.connection, safeRelativePath(input.relativePath), input.env);
157
+ }
158
+ async function deleteUserWorkspaceStorageFile(input) {
159
+ const context = await resolveWorkspaceContext(input, makeQuery(input.env));
160
+ return deleteWorkspaceFile(context.workspace, context.connection, safeRelativePath(input.relativePath), input.env);
161
+ }
162
+ async function listUserWorkspaceStorageFiles(input) {
163
+ const context = await resolveWorkspaceContext(input, makeQuery(input.env));
164
+ return listWorkspaceFiles(context.workspace, context.connection, input.subPrefix ? safeRelativePath(input.subPrefix) : "", input.env);
165
+ }
166
+ async function deleteUserWorkspaceStorageFolder(input) {
167
+ const context = await resolveWorkspaceContext(input, makeQuery(input.env));
168
+ const { deleteWorkspaceFolder } = await import("./workspaceFileCore-UURQPP62.js");
169
+ await deleteWorkspaceFolder(context.workspace, context.connection, input.env);
170
+ }
171
+
172
+ // src/core/googleDriveOAuthCore.ts
173
+ var STATE_TTL_MS = 10 * 60 * 1e3;
174
+ var encoder = new TextEncoder();
175
+ var decoder = new TextDecoder();
176
+ function bytesToBase64Url(bytes) {
177
+ let binary = "";
178
+ for (const byte of bytes) binary += String.fromCharCode(byte);
179
+ return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
180
+ }
181
+ function base64UrlToBytes(value) {
182
+ if (!/^[A-Za-z0-9_-]+$/.test(value)) throw new Error("Google Drive OAuth state is malformed.");
183
+ const base64 = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
184
+ const binary = atob(base64);
185
+ return Uint8Array.from(binary, (character) => character.charCodeAt(0));
186
+ }
187
+ function toCryptoBufferSource(bytes) {
188
+ const buffer = new ArrayBuffer(bytes.byteLength);
189
+ new Uint8Array(buffer).set(bytes);
190
+ return buffer;
191
+ }
192
+ async function stateSigningKey(secret, usages) {
193
+ return crypto.subtle.importKey(
194
+ "raw",
195
+ encoder.encode(secret),
196
+ { name: "HMAC", hash: "SHA-256" },
197
+ false,
198
+ usages
199
+ );
200
+ }
201
+ async function signPayload(payload, secret) {
202
+ const key = await stateSigningKey(secret, ["sign"]);
203
+ const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
204
+ return bytesToBase64Url(new Uint8Array(signature));
205
+ }
206
+ async function verifyPayload(payload, signature, secret) {
207
+ let signatureBytes;
208
+ try {
209
+ signatureBytes = base64UrlToBytes(signature);
210
+ } catch {
211
+ return false;
212
+ }
213
+ const key = await stateSigningKey(secret, ["verify"]);
214
+ return crypto.subtle.verify("HMAC", key, toCryptoBufferSource(signatureBytes), encoder.encode(payload));
215
+ }
216
+ function safeOrigin(value, label) {
217
+ try {
218
+ return new URL(value).origin;
219
+ } catch {
220
+ throw new Error(`Google Drive OAuth ${label} must be a valid absolute URL.`);
221
+ }
222
+ }
223
+ function validateReturnTo(returnToInput, callbackOrigin, config) {
224
+ let returnTo;
225
+ try {
226
+ returnTo = new URL(returnToInput, callbackOrigin);
227
+ } catch {
228
+ throw new Error("Google Drive OAuth return URL is invalid.");
229
+ }
230
+ if (returnTo.protocol !== "https:" && returnTo.hostname !== "localhost") {
231
+ throw new Error("Google Drive OAuth return URL must use HTTPS.");
232
+ }
233
+ if (returnTo.origin !== callbackOrigin && !config.allowedReturnOrigins.includes(returnTo.origin)) {
234
+ throw new Error(
235
+ "Google Drive OAuth return origin is not allowed. Add it to allowedReturnOrigins in the system-owned Google OAuth configuration."
236
+ );
237
+ }
238
+ return returnTo.toString();
239
+ }
240
+ function constantTimeEqual(left, right) {
241
+ const a = encoder.encode(left);
242
+ const b = encoder.encode(right);
243
+ let difference = a.length ^ b.length;
244
+ const length = Math.max(a.length, b.length);
245
+ for (let index = 0; index < length; index += 1) {
246
+ difference |= (a[index] || 0) ^ (b[index] || 0);
247
+ }
248
+ return difference === 0;
249
+ }
250
+ function randomNonce() {
251
+ const bytes = crypto.getRandomValues(new Uint8Array(32));
252
+ return bytesToBase64Url(bytes);
253
+ }
254
+ async function resolveConfig(query) {
255
+ return getSystemGoogleOAuthConfiguration(query);
256
+ }
257
+ async function createGoogleDriveAuthorizationRequest(input, query) {
258
+ const userId = String(input.userId || "").trim();
259
+ if (!userId) throw new Error("A verified Luth user is required to connect Google Drive.");
260
+ const config = await resolveConfig(query);
261
+ const callbackOrigin = safeOrigin(input.callbackOrigin, "callback origin");
262
+ const configuredCallbackOrigin = safeOrigin(config.redirectUri, "redirect URI");
263
+ if (callbackOrigin !== configuredCallbackOrigin) {
264
+ throw new Error(
265
+ "Google Drive OAuth callback origin does not match the system-owned redirectUri. Update the Google OAuth system configuration."
266
+ );
267
+ }
268
+ const returnTo = validateReturnTo(input.returnTo || callbackOrigin, callbackOrigin, config);
269
+ const issuedAt = Date.now();
270
+ const state = {
271
+ userId,
272
+ returnTo,
273
+ callbackOrigin,
274
+ nonce: randomNonce(),
275
+ issuedAt,
276
+ expiresAt: issuedAt + STATE_TTL_MS
277
+ };
278
+ const payload = bytesToBase64Url(encoder.encode(JSON.stringify(state)));
279
+ const signature = await signPayload(payload, config.stateSecret);
280
+ const signedState = `${payload}.${signature}`;
281
+ const authorizationUrl = GoogleDriveWorkspaceService.createAuthorizationUrl(
282
+ { clientId: config.clientId, redirectUri: config.redirectUri },
283
+ signedState,
284
+ [GOOGLE_DRIVE_WORKSPACE_SCOPE]
285
+ );
286
+ return {
287
+ authorizationUrl,
288
+ state: signedState,
289
+ nonce: state.nonce,
290
+ expiresAt: new Date(state.expiresAt).toISOString()
291
+ };
292
+ }
293
+ async function verifyGoogleDriveAuthorizationState(input, query) {
294
+ const config = await resolveConfig(query);
295
+ const parts = String(input.state || "").split(".");
296
+ if (parts.length !== 2) throw new Error("Google Drive OAuth state is malformed.");
297
+ const [payload, signature] = parts;
298
+ const signatureValid = await verifyPayload(payload, signature, config.stateSecret);
299
+ if (!signatureValid) throw new Error("Google Drive OAuth state signature is invalid.");
300
+ let parsed;
301
+ try {
302
+ parsed = JSON.parse(decoder.decode(base64UrlToBytes(payload)));
303
+ } catch {
304
+ throw new Error("Google Drive OAuth state payload is invalid.");
305
+ }
306
+ const callbackOrigin = safeOrigin(input.callbackOrigin, "callback origin");
307
+ const configuredCallbackOrigin = safeOrigin(config.redirectUri, "redirect URI");
308
+ if (!parsed || parsed.callbackOrigin !== callbackOrigin || callbackOrigin !== configuredCallbackOrigin) {
309
+ throw new Error("Google Drive OAuth callback origin does not match the signed authorization request.");
310
+ }
311
+ if (!parsed.userId || !parsed.nonce || !Number.isFinite(parsed.issuedAt) || !Number.isFinite(parsed.expiresAt)) {
312
+ throw new Error("Google Drive OAuth state is missing required authorization context.");
313
+ }
314
+ if (parsed.expiresAt < Date.now() || parsed.issuedAt > Date.now() + 3e4 || parsed.expiresAt - parsed.issuedAt > STATE_TTL_MS) {
315
+ throw new Error("Google Drive OAuth state has expired. Restart the connection flow.");
316
+ }
317
+ if (!constantTimeEqual(parsed.nonce, String(input.nonceCookie || ""))) {
318
+ throw new Error("Google Drive OAuth nonce validation failed. Restart the connection flow.");
319
+ }
320
+ const normalizedReturnTo = validateReturnTo(parsed.returnTo, callbackOrigin, config);
321
+ if (normalizedReturnTo !== parsed.returnTo) {
322
+ throw new Error("Google Drive OAuth return URL did not match the signed authorization context.");
323
+ }
324
+ return parsed;
325
+ }
326
+ async function completeGoogleDriveAuthorizationCallback(input, query) {
327
+ const authorization = await verifyGoogleDriveAuthorizationState({
328
+ state: input.state,
329
+ nonceCookie: input.nonceCookie,
330
+ callbackOrigin: input.callbackOrigin
331
+ }, query);
332
+ if (!String(input.code || "").trim()) {
333
+ throw new Error("Google Drive authorization code is required.");
334
+ }
335
+ const connection = await completeGoogleDriveAuthorization(authorization.userId, input.code, query);
336
+ return { connection, returnTo: authorization.returnTo };
337
+ }
338
+
339
+ // src/krnl-services.ts
340
+ var AuthServiceDefinition = createServiceDefinition({
341
+ id: "kloks.backend.auth",
342
+ name: "AuthService",
343
+ version: "1.0.0",
344
+ state: {
345
+ initial: { activeSessions: 0 }
346
+ },
347
+ operations: {
348
+ login: {
349
+ id: "AuthService.login",
350
+ name: "login",
351
+ handler: async (input) => loginSystemUser(input.email, input.password, Boolean(input.isAdmin), (sql, params) => queryUnifiedDb(sql, params, input.env), input.env)
352
+ },
353
+ resolveUser: {
354
+ id: "AuthService.resolveUser",
355
+ name: "resolveUser",
356
+ handler: async (input) => resolveUserFromToken(input.tokenOrUserId, (sql, params) => queryUnifiedDb(sql, params, input.env), input.env)
357
+ }
358
+ }
359
+ });
360
+ var authServiceInstance = createService(AuthServiceDefinition);
361
+ var AuthServiceFacade = {
362
+ id: AuthServiceDefinition.id,
363
+ name: AuthServiceDefinition.name,
364
+ version: AuthServiceDefinition.version,
365
+ runtime: "server",
366
+ deployment: "local",
367
+ definition: AuthServiceDefinition,
368
+ get telemetry() {
369
+ return authServiceInstance.telemetry;
370
+ },
371
+ createInstance: () => createService(AuthServiceDefinition),
372
+ execute: async (op, input) => {
373
+ await authServiceInstance.start();
374
+ return authServiceInstance.call(op, input);
375
+ }
376
+ };
377
+ var StorageServiceDefinition = createServiceDefinition({
378
+ id: "kloks.backend.storage",
379
+ name: "StorageService",
380
+ version: "1.0.0",
381
+ operations: {
382
+ getProviderCapabilities: {
383
+ id: "StorageService.getProviderCapabilities",
384
+ name: "getProviderCapabilities",
385
+ handler: async (input) => getStorageProviderCapabilities((sql, params) => queryUnifiedDb(sql, params, input.env))
386
+ },
387
+ getConnections: {
388
+ id: "StorageService.getConnections",
389
+ name: "getConnections",
390
+ handler: async (input) => listUserStorageConnections(input.userId, (sql, params) => queryUnifiedDb(sql, params, input.env))
391
+ },
392
+ testBackblazeCredentials: {
393
+ id: "StorageService.testBackblazeCredentials",
394
+ name: "testBackblazeCredentials",
395
+ handler: async (input) => testBackblazeCredentials(input.keyId, input.applicationKey)
396
+ },
397
+ /** Server-only operation for backend storage engines. Never bind this operation to browser HTTP routes. */
398
+ getConnectionsWithSecrets: {
399
+ id: "StorageService.getConnectionsWithSecrets",
400
+ name: "getConnectionsWithSecrets",
401
+ handler: async (input) => listUserStorageConnectionsWithSecrets(
402
+ input.userId,
403
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
404
+ )
405
+ },
406
+ setPrimaryConnection: {
407
+ id: "StorageService.setPrimaryConnection",
408
+ name: "setPrimaryConnection",
409
+ handler: async (input) => setPrimaryUserStorageConnection(
410
+ input.userId,
411
+ input.connectionId,
412
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
413
+ )
414
+ },
415
+ deleteConnection: {
416
+ id: "StorageService.deleteConnection",
417
+ name: "deleteConnection",
418
+ handler: async (input) => deleteUserStorageConnection(
419
+ input.userId,
420
+ input.connectionId,
421
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
422
+ )
423
+ },
424
+ createBackblazeConnection: {
425
+ id: "StorageService.createBackblazeConnection",
426
+ name: "createBackblazeConnection",
427
+ handler: async (input) => createBackblazeStorageConnection(input, (sql, params) => queryUnifiedDb(sql, params, input.env))
428
+ },
429
+ listBackblazeConnectionBuckets: {
430
+ id: "StorageService.listBackblazeConnectionBuckets",
431
+ name: "listBackblazeConnectionBuckets",
432
+ handler: async (input) => listBackblazeBucketsForConnection(
433
+ input.userId,
434
+ input.connectionId,
435
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
436
+ )
437
+ },
438
+ createGoogleDriveAuthorizationRequest: {
439
+ id: "StorageService.createGoogleDriveAuthorizationRequest",
440
+ name: "createGoogleDriveAuthorizationRequest",
441
+ handler: async (input) => createGoogleDriveAuthorizationRequest(
442
+ input,
443
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
444
+ )
445
+ },
446
+ verifyGoogleDriveAuthorizationState: {
447
+ id: "StorageService.verifyGoogleDriveAuthorizationState",
448
+ name: "verifyGoogleDriveAuthorizationState",
449
+ handler: async (input) => verifyGoogleDriveAuthorizationState(
450
+ input,
451
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
452
+ )
453
+ },
454
+ completeGoogleDriveAuthorization: {
455
+ id: "StorageService.completeGoogleDriveAuthorization",
456
+ name: "completeGoogleDriveAuthorization",
457
+ handler: async (input) => completeGoogleDriveAuthorization(
458
+ input.userId,
459
+ input.code,
460
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
461
+ )
462
+ },
463
+ /** Server-only token persistence for the shared Google Drive adapter. */
464
+ persistGoogleDriveTokens: {
465
+ id: "StorageService.persistGoogleDriveTokens",
466
+ name: "persistGoogleDriveTokens",
467
+ handler: async (input) => persistGoogleDriveTokens(
468
+ input.userId,
469
+ input.connectionId,
470
+ input.tokens,
471
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
472
+ )
473
+ },
474
+ listGoogleDriveFolders: {
475
+ id: "StorageService.listGoogleDriveFolders",
476
+ name: "listGoogleDriveFolders",
477
+ handler: async (input) => listGoogleDriveFoldersForConnection(
478
+ input.userId,
479
+ input.connectionId,
480
+ input.parentFolderId,
481
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
482
+ )
483
+ },
484
+ selectGoogleDriveRootFolder: {
485
+ id: "StorageService.selectGoogleDriveRootFolder",
486
+ name: "selectGoogleDriveRootFolder",
487
+ handler: async (input) => selectGoogleDriveRootFolder(
488
+ input.userId,
489
+ input.connectionId,
490
+ input.folderId,
491
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
492
+ )
493
+ },
494
+ getGoogleDriveAccountIdentity: {
495
+ id: "StorageService.getGoogleDriveAccountIdentity",
496
+ name: "getGoogleDriveAccountIdentity",
497
+ handler: async (input) => getGoogleDriveAccountIdentityForUser(
498
+ input.userId,
499
+ input.connectionId,
500
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
501
+ )
502
+ },
503
+ testGoogleDriveConnection: {
504
+ id: "StorageService.testGoogleDriveConnection",
505
+ name: "testGoogleDriveConnection",
506
+ handler: async (input) => testGoogleDriveConnectionForUser(
507
+ input.userId,
508
+ input.connectionId,
509
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
510
+ )
511
+ },
512
+ writeGoogleDriveFile: {
513
+ id: "StorageService.writeGoogleDriveFile",
514
+ name: "writeGoogleDriveFile",
515
+ handler: async (input) => writeGoogleDriveFileForConnection(
516
+ input.userId,
517
+ input.connectionId,
518
+ input.path,
519
+ input.data,
520
+ input.contentType,
521
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
522
+ )
523
+ },
524
+ readGoogleDriveFile: {
525
+ id: "StorageService.readGoogleDriveFile",
526
+ name: "readGoogleDriveFile",
527
+ handler: async (input) => readGoogleDriveFileForConnection(
528
+ input.userId,
529
+ input.connectionId,
530
+ input.path,
531
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
532
+ )
533
+ },
534
+ deleteGoogleDriveFile: {
535
+ id: "StorageService.deleteGoogleDriveFile",
536
+ name: "deleteGoogleDriveFile",
537
+ handler: async (input) => deleteGoogleDriveFileForConnection(
538
+ input.userId,
539
+ input.connectionId,
540
+ input.path,
541
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
542
+ )
543
+ },
544
+ listGoogleDriveFiles: {
545
+ id: "StorageService.listGoogleDriveFiles",
546
+ name: "listGoogleDriveFiles",
547
+ handler: async (input) => listGoogleDriveFilesForConnection(
548
+ input.userId,
549
+ input.connectionId,
550
+ input.path || "",
551
+ (sql, params) => queryUnifiedDb(sql, params, input.env)
552
+ )
553
+ },
554
+ writeWorkspaceStorageFile: {
555
+ id: "StorageService.writeWorkspaceStorageFile",
556
+ name: "writeWorkspaceStorageFile",
557
+ handler: async (input) => writeUserWorkspaceStorageFile(input)
558
+ },
559
+ readWorkspaceStorageFile: {
560
+ id: "StorageService.readWorkspaceStorageFile",
561
+ name: "readWorkspaceStorageFile",
562
+ handler: async (input) => readUserWorkspaceStorageFile(input)
563
+ },
564
+ deleteWorkspaceStorageFile: {
565
+ id: "StorageService.deleteWorkspaceStorageFile",
566
+ name: "deleteWorkspaceStorageFile",
567
+ handler: async (input) => deleteUserWorkspaceStorageFile(input)
568
+ },
569
+ deleteWorkspaceStorageFolder: {
570
+ id: "StorageService.deleteWorkspaceStorageFolder",
571
+ name: "deleteWorkspaceStorageFolder",
572
+ handler: async (input) => deleteUserWorkspaceStorageFolder(input)
573
+ },
574
+ listWorkspaceStorageFiles: {
575
+ id: "StorageService.listWorkspaceStorageFiles",
576
+ name: "listWorkspaceStorageFiles",
577
+ handler: async (input) => listUserWorkspaceStorageFiles(input)
578
+ },
579
+ listBackblazeBuckets: {
580
+ id: "StorageService.listBackblazeBuckets",
581
+ name: "listBackblazeBuckets",
582
+ handler: async (input) => b2ListBuckets(input.keyId, input.applicationKey)
583
+ },
584
+ resolveAdapterType: {
585
+ id: "StorageService.resolveAdapterType",
586
+ name: "resolveAdapterType",
587
+ handler: async (input) => {
588
+ const normalized = input.provider === "local" ? "local_fs" : input.provider;
589
+ if (normalized === "local_fs") {
590
+ return {
591
+ provider: "local",
592
+ initialized: true,
593
+ runtimeSupport: "node_only",
594
+ requiresNodeAdapter: true
595
+ };
596
+ }
597
+ return {
598
+ provider: normalized,
599
+ initialized: true,
600
+ runtimeSupport: "fetch",
601
+ requiresNodeAdapter: false
602
+ };
603
+ }
604
+ }
605
+ }
606
+ });
607
+ var storageServiceInstance = createService(StorageServiceDefinition);
608
+ var StorageServiceFacade = {
609
+ id: StorageServiceDefinition.id,
610
+ name: StorageServiceDefinition.name,
611
+ version: StorageServiceDefinition.version,
612
+ runtime: "server",
613
+ deployment: "local",
614
+ definition: StorageServiceDefinition,
615
+ get telemetry() {
616
+ return storageServiceInstance.telemetry;
617
+ },
618
+ createInstance: () => createService(StorageServiceDefinition),
619
+ execute: async (op, input) => {
620
+ await storageServiceInstance.start();
621
+ return storageServiceInstance.call(op, input);
622
+ }
623
+ };
624
+ var WorkspaceServiceDefinition = createServiceDefinition({
625
+ id: "kloks.backend.workspace",
626
+ name: "WorkspaceService",
627
+ version: "1.0.0",
628
+ operations: {
629
+ listWorkspaces: {
630
+ id: "WorkspaceService.listWorkspaces",
631
+ name: "listWorkspaces",
632
+ handler: async (input) => getWorkspaces(input.userId, input.env)
633
+ },
634
+ findWorkspace: {
635
+ id: "WorkspaceService.findWorkspace",
636
+ name: "findWorkspace",
637
+ handler: async (input) => findUserWorkspace(input.workspaceId, input.env)
638
+ },
639
+ createWorkspace: {
640
+ id: "WorkspaceService.createWorkspace",
641
+ name: "createWorkspace",
642
+ handler: async (input) => createWorkspace(input.userId, input.workspace, input.env)
643
+ },
644
+ updateWorkspace: {
645
+ id: "WorkspaceService.updateWorkspace",
646
+ name: "updateWorkspace",
647
+ handler: async (input) => updateWorkspace(input.userId, input.params, input.env)
648
+ },
649
+ deleteWorkspace: {
650
+ id: "WorkspaceService.deleteWorkspace",
651
+ name: "deleteWorkspace",
652
+ handler: async (input) => deleteWorkspace(input.userId, input.workspaceId, input.env)
653
+ },
654
+ validateWorkspaceConfig: {
655
+ id: "WorkspaceService.validateWorkspaceConfig",
656
+ name: "validateWorkspaceConfig",
657
+ handler: async (input) => {
658
+ const sanitized = sanitizeWorkspaceName(input.name);
659
+ const folderName = formatCanonicalWorkspaceFolderName(
660
+ input.appName ?? "app",
661
+ input.userName ?? "user",
662
+ sanitized
663
+ );
664
+ return {
665
+ valid: Boolean(input.id && sanitized),
666
+ workspaceId: input.id,
667
+ name: sanitized,
668
+ folderName,
669
+ storageType: input.storageType ?? "local"
670
+ };
671
+ }
672
+ }
673
+ }
674
+ });
675
+ var workspaceServiceInstance = createService(WorkspaceServiceDefinition);
676
+ var WorkspaceServiceFacade = {
677
+ id: WorkspaceServiceDefinition.id,
678
+ name: WorkspaceServiceDefinition.name,
679
+ version: WorkspaceServiceDefinition.version,
680
+ runtime: "server",
681
+ deployment: "local",
682
+ definition: WorkspaceServiceDefinition,
683
+ get telemetry() {
684
+ return workspaceServiceInstance.telemetry;
685
+ },
686
+ createInstance: () => createService(WorkspaceServiceDefinition),
687
+ execute: async (op, input) => {
688
+ await workspaceServiceInstance.start();
689
+ return workspaceServiceInstance.call(op, input);
690
+ }
691
+ };
692
+ var ControlPlaneServiceDefinition = createServiceDefinition({
693
+ id: "kloks.backend.controlPlane",
694
+ name: "ControlPlaneService",
695
+ version: "1.0.0",
696
+ operations: {
697
+ status: {
698
+ id: "ControlPlaneService.status",
699
+ name: "status",
700
+ handler: async () => ({
701
+ healthy: true,
702
+ timestamp: Date.now()
703
+ })
704
+ }
705
+ }
706
+ });
707
+ var controlPlaneServiceInstance = createService(ControlPlaneServiceDefinition);
708
+ var ControlPlaneServiceFacade = {
709
+ id: ControlPlaneServiceDefinition.id,
710
+ name: ControlPlaneServiceDefinition.name,
711
+ version: ControlPlaneServiceDefinition.version,
712
+ runtime: "server",
713
+ deployment: "local",
714
+ definition: ControlPlaneServiceDefinition,
715
+ get telemetry() {
716
+ return controlPlaneServiceInstance.telemetry;
717
+ },
718
+ createInstance: () => createService(ControlPlaneServiceDefinition),
719
+ execute: async (op, input) => {
720
+ await controlPlaneServiceInstance.start();
721
+ return controlPlaneServiceInstance.call(op, input);
722
+ }
723
+ };
724
+ var DatabaseServiceDefinition = createServiceDefinition({
725
+ id: "kloks.backend.database",
726
+ name: "DatabaseService",
727
+ version: "1.0.0",
728
+ operations: {
729
+ query: {
730
+ id: "DatabaseService.query",
731
+ name: "query",
732
+ handler: async (input) => queryUnifiedDb(input.sql, input.params || [], input.env)
733
+ },
734
+ isHealthy: {
735
+ id: "DatabaseService.isHealthy",
736
+ name: "isHealthy",
737
+ handler: async (input) => {
738
+ try {
739
+ await queryUnifiedDb("SELECT 1 AS ok", [], input.env);
740
+ return { healthy: true };
741
+ } catch {
742
+ return { healthy: false, reason: "SYSTEM_DATABASE_UNAVAILABLE" };
743
+ }
744
+ }
745
+ }
746
+ }
747
+ });
748
+ var databaseServiceInstance = createService(DatabaseServiceDefinition);
749
+ var DatabaseServiceFacade = {
750
+ id: DatabaseServiceDefinition.id,
751
+ name: DatabaseServiceDefinition.name,
752
+ version: DatabaseServiceDefinition.version,
753
+ runtime: "server",
754
+ deployment: "local",
755
+ definition: DatabaseServiceDefinition,
756
+ createInstance: () => createService(DatabaseServiceDefinition),
757
+ execute: async (op, input) => {
758
+ await databaseServiceInstance.start();
759
+ return databaseServiceInstance.call(op, input);
760
+ }
761
+ };
762
+ var GeminiServiceDefinition = createServiceDefinition({
763
+ id: "kloks.backend.gemini",
764
+ name: "GeminiService",
765
+ version: "1.0.0",
766
+ operations: {
767
+ generateText: {
768
+ id: "GeminiService.generateText",
769
+ name: "generateText",
770
+ handler: async (input) => {
771
+ return { text: `[GeminiResponse] Generated response for: ${input.prompt}`, model: input.model ?? "gemini-2.5-flash", timestamp: Date.now() };
772
+ }
773
+ }
774
+ }
775
+ });
776
+ var geminiServiceInstance = createService(GeminiServiceDefinition);
777
+ var GeminiServiceFacade = {
778
+ id: GeminiServiceDefinition.id,
779
+ name: GeminiServiceDefinition.name,
780
+ version: GeminiServiceDefinition.version,
781
+ runtime: "server",
782
+ deployment: "remote",
783
+ definition: GeminiServiceDefinition,
784
+ createInstance: () => createService(GeminiServiceDefinition),
785
+ execute: async (op, input) => {
786
+ await geminiServiceInstance.start();
787
+ return geminiServiceInstance.call(op, input);
788
+ }
789
+ };
790
+ var krnlAuthServiceDefinition = AuthServiceDefinition;
791
+ var krnlAuthServiceFacade = AuthServiceFacade;
792
+ var krnlStorageServiceDefinition = StorageServiceDefinition;
793
+ var krnlStorageServiceFacade = StorageServiceFacade;
794
+ var krnlWorkspaceServiceDefinition = WorkspaceServiceDefinition;
795
+ var krnlWorkspaceServiceFacade = WorkspaceServiceFacade;
796
+ var krnlControlPlaneServiceDefinition = ControlPlaneServiceDefinition;
797
+ var krnlControlPlaneServiceFacade = ControlPlaneServiceFacade;
798
+ var krnlDatabaseServiceDefinition = DatabaseServiceDefinition;
799
+ var krnlDatabaseServiceFacade = DatabaseServiceFacade;
800
+ var krnlGeminiServiceDefinition = GeminiServiceDefinition;
801
+ var krnlGeminiServiceFacade = GeminiServiceFacade;
802
+ var SrklServiceDefinition = createServiceDefinition({
803
+ id: "kloks.backend.srkl",
804
+ name: "SrklService",
805
+ version: "1.0.0",
806
+ operations: {
807
+ getAccounts: {
808
+ id: "SrklService.getAccounts",
809
+ name: "getAccounts",
810
+ handler: async (input) => getSrklAccounts(input.userId, input.service, (sql, params) => queryUnifiedDb(sql, params, input.env))
811
+ },
812
+ getPrimaryDeploymentUrl: {
813
+ id: "SrklService.getPrimaryDeploymentUrl",
814
+ name: "getPrimaryDeploymentUrl",
815
+ handler: async (input) => ({
816
+ success: true,
817
+ deploymentUrl: await getPrimarySrklDeploymentUrl((sql, params) => queryUnifiedDb(sql, params, input.env))
818
+ })
819
+ },
820
+ listBackblazeBuckets: {
821
+ id: "SrklService.listBackblazeBuckets",
822
+ name: "listBackblazeBuckets",
823
+ handler: async (input) => srklListBackblazeBuckets(
824
+ input.keyId,
825
+ input.applicationKey,
826
+ void 0,
827
+ void 0,
828
+ input.userId,
829
+ (sql, params) => queryUnifiedDb(sql, params, input.env),
830
+ input.accountId
831
+ )
832
+ }
833
+ }
834
+ });
835
+ var srklServiceInstance = createService(SrklServiceDefinition);
836
+ var SrklServiceFacade = {
837
+ id: SrklServiceDefinition.id,
838
+ name: SrklServiceDefinition.name,
839
+ version: SrklServiceDefinition.version,
840
+ runtime: "server",
841
+ deployment: "remote",
842
+ definition: SrklServiceDefinition,
843
+ createInstance: () => createService(SrklServiceDefinition),
844
+ execute: async (op, input) => {
845
+ await srklServiceInstance.start();
846
+ return srklServiceInstance.call(op, input);
847
+ }
848
+ };
849
+ var krnlSrklServiceDefinition = SrklServiceDefinition;
850
+ var krnlSrklServiceFacade = SrklServiceFacade;
851
+
852
+ export {
853
+ writeUserWorkspaceStorageFile,
854
+ readUserWorkspaceStorageFile,
855
+ deleteUserWorkspaceStorageFile,
856
+ listUserWorkspaceStorageFiles,
857
+ deleteUserWorkspaceStorageFolder,
858
+ createGoogleDriveAuthorizationRequest,
859
+ verifyGoogleDriveAuthorizationState,
860
+ completeGoogleDriveAuthorizationCallback,
861
+ AuthServiceDefinition,
862
+ AuthServiceFacade,
863
+ StorageServiceDefinition,
864
+ StorageServiceFacade,
865
+ WorkspaceServiceDefinition,
866
+ WorkspaceServiceFacade,
867
+ ControlPlaneServiceDefinition,
868
+ ControlPlaneServiceFacade,
869
+ DatabaseServiceDefinition,
870
+ DatabaseServiceFacade,
871
+ GeminiServiceDefinition,
872
+ GeminiServiceFacade,
873
+ krnlAuthServiceDefinition,
874
+ krnlAuthServiceFacade,
875
+ krnlStorageServiceDefinition,
876
+ krnlStorageServiceFacade,
877
+ krnlWorkspaceServiceDefinition,
878
+ krnlWorkspaceServiceFacade,
879
+ krnlControlPlaneServiceDefinition,
880
+ krnlControlPlaneServiceFacade,
881
+ krnlDatabaseServiceDefinition,
882
+ krnlDatabaseServiceFacade,
883
+ krnlGeminiServiceDefinition,
884
+ krnlGeminiServiceFacade,
885
+ SrklServiceDefinition,
886
+ SrklServiceFacade,
887
+ krnlSrklServiceDefinition,
888
+ krnlSrklServiceFacade
889
+ };