@ultrst-armada/kloks 2.0.4 → 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 +636 -456
  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
@@ -1,3 +1,21 @@
1
+ import {
2
+ CANONICAL_SRKL_URL,
3
+ SrklClient,
4
+ SrklCredentialRegistry,
5
+ SrklVaultAccessClient,
6
+ createSrklClient,
7
+ decryptVaultBufferInBrowser,
8
+ getPrimarySrklDeploymentUrl as getPrimarySrklDeploymentUrl2,
9
+ getSrklAccounts as getSrklAccounts2,
10
+ getSrklStatus,
11
+ globalCredentialRegistry,
12
+ hexToBytes,
13
+ listBackblazeBuckets,
14
+ srklListBackblazeBuckets as srklListBackblazeBuckets2,
15
+ srklService,
16
+ syncSrklAccounts,
17
+ useSrklServices
18
+ } from "./chunk-WYEVA4RC.js";
1
19
  import "./chunk-G4EDIAHW.js";
2
20
  import {
3
21
  RemoteWorkspaceService,
@@ -13,7 +31,7 @@ import {
13
31
  setWorkingWorkspaceConfig,
14
32
  syncWorkspace,
15
33
  workingWorkspaceService
16
- } from "./chunk-Z6G32NQQ.js";
34
+ } from "./chunk-XKUWLO2M.js";
17
35
  import {
18
36
  CompositeBackend,
19
37
  EndpointGenerator,
@@ -26,26 +44,24 @@ import {
26
44
  exportGraphAsJsonFile,
27
45
  nodeGraphPersistence,
28
46
  parseGraphJsonFile,
29
- validateGraphDocument
30
- } from "./chunk-OXEP3AP6.js";
47
+ validateGraphDocument,
48
+ workspaceGraphService
49
+ } from "./chunk-Z2CT2MJ2.js";
31
50
  import {
32
- CANONICAL_SRKL_URL,
33
- SrklClient,
34
- SrklCredentialRegistry,
35
- SrklVaultAccessClient,
36
- createSrklClient,
37
- decryptVaultBufferInBrowser,
38
- getPrimarySrklDeploymentUrl as getPrimarySrklDeploymentUrl2,
39
- getSrklAccounts as getSrklAccounts2,
40
- getSrklStatus,
41
- globalCredentialRegistry,
42
- hexToBytes,
43
- listBackblazeBuckets,
44
- srklListBackblazeBuckets as srklListBackblazeBuckets2,
45
- srklService,
46
- syncSrklAccounts,
47
- useSrklServices
48
- } from "./chunk-FK3OAUXM.js";
51
+ BackblazeB2Adapter,
52
+ BucketStorageService,
53
+ LocalFSAdapter,
54
+ S3Adapter,
55
+ StorageAdapterFactory,
56
+ SupabaseStorageAdapter,
57
+ ensureS3DirectoryMarker,
58
+ permanentDeleteS3Folder,
59
+ permanentDeleteS3Object,
60
+ renameS3Folder
61
+ } from "./chunk-AUNIGE6Q.js";
62
+ import {
63
+ GoogleDriveStorageService
64
+ } from "./chunk-TRJVVNO7.js";
49
65
  import "./chunk-LV55WKZR.js";
50
66
  import "./chunk-WVDSMTW3.js";
51
67
  import {
@@ -64,21 +80,26 @@ import {
64
80
  detectDatabaseEngine,
65
81
  getSystemDatabaseUrls,
66
82
  resolveSystemDatabaseClusterNodes
67
- } from "./chunk-ZBNSK26X.js";
68
- import {
69
- resolveSystemDatabaseUrl,
70
- tryResolveSystemDatabaseUrl
71
- } from "./chunk-GYSZ6CAX.js";
83
+ } from "./chunk-CV55JMT7.js";
84
+ import "./chunk-LC6ULEM2.js";
72
85
  import "./chunk-DAG2L4RN.js";
73
86
  import {
74
87
  WorkspaceCloneSyncEngine
75
- } from "./chunk-NY2SQOXI.js";
88
+ } from "./chunk-CDRHYO44.js";
89
+ import {
90
+ isSecretMasked,
91
+ normalizeBackblazeCredentials,
92
+ resolveBackblazeEndpoint
93
+ } from "./chunk-HUY4272L.js";
94
+ import {
95
+ BaseStorageAdapter
96
+ } from "./chunk-5Y7K7HAT.js";
76
97
  import {
77
98
  BaseApiRoute,
78
99
  createSSEResponse,
79
100
  withAuth,
80
101
  withCors
81
- } from "./chunk-POLVHTHJ.js";
102
+ } from "./chunk-KCPQWJBO.js";
82
103
  import {
83
104
  LuthAuthClient,
84
105
  LuthAuthClient2,
@@ -112,6 +133,9 @@ import {
112
133
  WebSocketTransport,
113
134
  createBackendClient
114
135
  } from "./chunk-NIP22V2G.js";
136
+ import {
137
+ SkipoBase
138
+ } from "./chunk-LMY6MGFD.js";
115
139
  import {
116
140
  AIInferenceServiceDefinition,
117
141
  AIInferenceServiceFacade,
@@ -157,10 +181,12 @@ import {
157
181
  SrklServiceFacade,
158
182
  StorageServiceDefinition,
159
183
  StorageServiceFacade,
160
- WorkspaceGraphServiceDefinition,
161
- WorkspaceGraphServiceFacade,
162
184
  WorkspaceServiceDefinition,
163
185
  WorkspaceServiceFacade,
186
+ completeGoogleDriveAuthorizationCallback,
187
+ createGoogleDriveAuthorizationRequest,
188
+ deleteUserWorkspaceStorageFile,
189
+ deleteUserWorkspaceStorageFolder,
164
190
  krnlAuthServiceDefinition,
165
191
  krnlAuthServiceFacade,
166
192
  krnlControlPlaneServiceDefinition,
@@ -173,88 +199,99 @@ import {
173
199
  krnlSrklServiceFacade,
174
200
  krnlStorageServiceDefinition,
175
201
  krnlStorageServiceFacade,
176
- krnlWorkspaceGraphServiceDefinition,
177
- krnlWorkspaceGraphServiceFacade,
178
202
  krnlWorkspaceServiceDefinition,
179
- krnlWorkspaceServiceFacade
180
- } from "./chunk-LMOM7CST.js";
203
+ krnlWorkspaceServiceFacade,
204
+ listUserWorkspaceStorageFiles,
205
+ readUserWorkspaceStorageFile,
206
+ verifyGoogleDriveAuthorizationState,
207
+ writeUserWorkspaceStorageFile
208
+ } from "./chunk-ICVDGH2I.js";
209
+ import {
210
+ getPrimarySrklDeploymentUrl,
211
+ getSrklAccounts,
212
+ srklListBackblazeBuckets
213
+ } from "./chunk-TRP76UR2.js";
181
214
  import {
182
215
  formatCanonicalWorkspaceFolderName,
183
216
  sanitizeWorkspaceName
184
217
  } from "./chunk-FZKBTF34.js";
185
- import {
186
- workspaceGraphService
187
- } from "./chunk-AOZSDRNY.js";
188
- import {
189
- BackblazeB2Adapter,
190
- BucketStorageService,
191
- LocalFSAdapter,
192
- S3Adapter,
193
- StorageAdapterFactory,
194
- SupabaseStorageAdapter,
195
- ensureS3DirectoryMarker,
196
- permanentDeleteS3Folder,
197
- permanentDeleteS3Object,
198
- renameS3Folder
199
- } from "./chunk-SQKG3S6P.js";
200
218
  import {
201
219
  createWorkspace,
202
220
  deleteWorkspace,
203
- deleteWorkspaceFile,
204
- deleteWorkspaceFolder,
205
221
  findUserWorkspace,
206
- getWorkspaceFolderPrefix,
207
222
  getWorkspaceStorageDetails,
208
223
  getWorkspaces,
209
- isB2Workspace,
210
- listWorkspaceFiles,
211
224
  loadWorkspaceData,
212
- readWorkspaceFile,
213
225
  renameAppInWorkspaceData,
214
226
  resolveWorkspaceConnection,
215
227
  saveWorkspaceData,
216
228
  syncWorkspaceCreateToBucket,
217
229
  syncWorkspaceDataToBucket,
218
230
  syncWorkspaceDeleteToBucket,
219
- updateWorkspace,
220
- writeWorkspaceFile
221
- } from "./chunk-JGUWYVOL.js";
231
+ updateWorkspace
232
+ } from "./chunk-IRNQXVYA.js";
222
233
  import {
223
- GoogleDriveStorageService
224
- } from "./chunk-OQRQCDS6.js";
225
- import {
226
- getPrimarySrklDeploymentUrl,
227
- getSrklAccounts,
228
- srklListBackblazeBuckets
229
- } from "./chunk-KPLDYX5Z.js";
234
+ configureLocalWorkspaceFileAdapter,
235
+ deleteWorkspaceFile,
236
+ deleteWorkspaceFolder,
237
+ getWorkspaceFolderPrefix,
238
+ isB2Workspace,
239
+ isGoogleDriveWorkspace,
240
+ listWorkspaceFiles,
241
+ normalizeWorkspaceStoragePath,
242
+ readWorkspaceFile,
243
+ writeWorkspaceFile
244
+ } from "./chunk-BRNWUIH5.js";
230
245
  import {
231
- b2DeleteFileVersion,
232
- b2DeleteFolder,
233
246
  cleanDbUrl,
234
- getB2BucketId,
247
+ completeGoogleDriveAuthorization,
248
+ configureUnifiedDatabaseEnvironmentResolver,
249
+ createBackblazeStorageConnection,
250
+ createGoogleDriveWorkspaceClient,
251
+ deleteGoogleDriveFileForConnection,
252
+ deleteUserStorageConnection,
253
+ getGoogleDriveAccountIdentityForUser,
254
+ getStorageProviderCapabilities,
255
+ getSystemGoogleOAuthConfiguration,
235
256
  getUnifiedDbUrl,
236
- queryUnifiedDb
237
- } from "./chunk-JCMB7BIM.js";
257
+ listBackblazeBucketsForConnection,
258
+ listGoogleDriveFilesForConnection,
259
+ listGoogleDriveFoldersForConnection,
260
+ listUserStorageConnections,
261
+ listUserStorageConnectionsWithSecrets,
262
+ persistGoogleDriveTokens,
263
+ queryUnifiedDb,
264
+ readGoogleDriveFileForConnection,
265
+ resolveUserStorageConnectionSecret,
266
+ resolveUserWorkspaceStorageAssociation,
267
+ selectGoogleDriveRootFolder,
268
+ setPrimaryUserStorageConnection,
269
+ testBackblazeCredentials,
270
+ testGoogleDriveConnectionForUser,
271
+ toPublicStorageConnection,
272
+ writeGoogleDriveFileForConnection
273
+ } from "./chunk-FSOOAU6G.js";
238
274
  import {
239
275
  loginSystemUser,
240
276
  resolveUserFromToken
241
277
  } from "./chunk-2COYZMUJ.js";
242
- import {
243
- isSecretMasked,
244
- normalizeBackblazeCredentials,
245
- resolveBackblazeEndpoint
246
- } from "./chunk-HUY4272L.js";
247
- import {
248
- BaseStorageAdapter
249
- } from "./chunk-5F5V7NAG.js";
250
278
  import {
251
279
  authorizeB2,
280
+ b2DeleteFileVersion,
281
+ b2DeleteFolder,
252
282
  b2DownloadFile,
253
283
  b2ListBuckets,
254
284
  b2ListFileNames,
255
- b2UploadFile
256
- } from "./chunk-4QEMALXF.js";
257
- import "./chunk-OWMQLML7.js";
285
+ b2UploadFile2 as b2UploadFile,
286
+ getB2BucketId
287
+ } from "./chunk-I6T64MLT.js";
288
+ import {
289
+ normalizeSystemEnvironment,
290
+ resolveSystemDatabaseUrl,
291
+ resolveSystemDatabaseUrlCandidates,
292
+ tryResolveSystemDatabaseUrl
293
+ } from "./chunk-IP6XWQU2.js";
294
+ import "./chunk-EMSSTOOK.js";
258
295
  import {
259
296
  DeterministicEndpointExecutor,
260
297
  deterministicEndpointExecutor
@@ -295,7 +332,6 @@ import {
295
332
  } from "./chunk-JSQZAFBU.js";
296
333
 
297
334
  // src/data/BaseDataProvider.ts
298
- import { SkipoBase } from "@ultrst-armada/kloks/functions/base";
299
335
  var BaseDataProvider = class extends SkipoBase {
300
336
  };
301
337
 
@@ -418,10 +454,79 @@ function validateServiceDefinition(def) {
418
454
  return { valid: true };
419
455
  }
420
456
 
421
- // src/core/SrklStorageService.ts
457
+ // src/core/workspaceFileNodeAdapter.ts
422
458
  import { promises as fs } from "fs";
423
459
  import path from "path";
424
- var ACCOUNTS_FILE = path.resolve(".skipo/accounts.json");
460
+ function resolveSafe(relativePath) {
461
+ const root = path.resolve(process.cwd());
462
+ const resolved = path.resolve(root, String(relativePath || ""));
463
+ if (resolved !== root && !resolved.startsWith(root + path.sep)) {
464
+ throw new Error("Workspace file path escapes the configured local storage root.");
465
+ }
466
+ return resolved;
467
+ }
468
+ async function listFiles(directory, root) {
469
+ const output = [];
470
+ let entries;
471
+ try {
472
+ entries = await fs.readdir(directory, { withFileTypes: true });
473
+ } catch {
474
+ return output;
475
+ }
476
+ for (const entry of entries) {
477
+ if (entry.isSymbolicLink()) continue;
478
+ const fullPath = path.join(directory, entry.name);
479
+ if (entry.isDirectory()) {
480
+ output.push(...await listFiles(fullPath, root));
481
+ } else if (entry.isFile()) {
482
+ const stat = await fs.stat(fullPath);
483
+ output.push({
484
+ fileName: path.relative(root, fullPath).replace(/\\/g, "/"),
485
+ sizeBytes: stat.size
486
+ });
487
+ }
488
+ }
489
+ return output;
490
+ }
491
+ configureLocalWorkspaceFileAdapter({
492
+ async write(filePath, content) {
493
+ const target = resolveSafe(filePath);
494
+ await fs.mkdir(path.dirname(target), { recursive: true });
495
+ await fs.writeFile(target, content);
496
+ },
497
+ async read(filePath) {
498
+ try {
499
+ return new Uint8Array(await fs.readFile(resolveSafe(filePath)));
500
+ } catch (error) {
501
+ if (error?.code === "ENOENT") return null;
502
+ throw error;
503
+ }
504
+ },
505
+ async delete(filePath) {
506
+ try {
507
+ await fs.unlink(resolveSafe(filePath));
508
+ return true;
509
+ } catch (error) {
510
+ if (error?.code === "ENOENT") return false;
511
+ throw error;
512
+ }
513
+ },
514
+ async list(directory) {
515
+ const root = resolveSafe(directory);
516
+ return listFiles(root, root);
517
+ },
518
+ async deleteFolder(directory) {
519
+ await fs.rm(resolveSafe(directory), { recursive: true, force: true });
520
+ }
521
+ });
522
+
523
+ // src/core/unifiedDbNodeAdapter.ts
524
+ configureUnifiedDatabaseEnvironmentResolver(() => process.env);
525
+
526
+ // src/core/SrklStorageService.ts
527
+ import { promises as fs2 } from "fs";
528
+ import path2 from "path";
529
+ var ACCOUNTS_FILE = path2.resolve(".skipo/accounts.json");
425
530
  var SrklStorageService = class {
426
531
  srklBaseUrl;
427
532
  constructor(srklBaseUrl) {
@@ -535,10 +640,10 @@ var SrklStorageService = class {
535
640
  }
536
641
  async persistWorkspaceConfig(wsId, config) {
537
642
  try {
538
- await fs.mkdir(path.dirname(ACCOUNTS_FILE), { recursive: true });
643
+ await fs2.mkdir(path2.dirname(ACCOUNTS_FILE), { recursive: true });
539
644
  let accounts = {};
540
645
  try {
541
- accounts = JSON.parse(await fs.readFile(ACCOUNTS_FILE, "utf-8"));
646
+ accounts = JSON.parse(await fs2.readFile(ACCOUNTS_FILE, "utf-8"));
542
647
  } catch {
543
648
  accounts = {};
544
649
  }
@@ -549,7 +654,7 @@ var SrklStorageService = class {
549
654
  ws.storageConfig = config;
550
655
  ws.storageProvider = "backblaze_b2";
551
656
  ws.updatedAt = Date.now();
552
- await fs.writeFile(ACCOUNTS_FILE, JSON.stringify(accounts, null, 2), "utf-8");
657
+ await fs2.writeFile(ACCOUNTS_FILE, JSON.stringify(accounts, null, 2), "utf-8");
553
658
  return;
554
659
  }
555
660
  }
@@ -574,7 +679,7 @@ var SrklStorageService = class {
574
679
  });
575
680
  }
576
681
  try {
577
- const raw = await fs.readFile(ACCOUNTS_FILE, "utf-8");
682
+ const raw = await fs2.readFile(ACCOUNTS_FILE, "utf-8");
578
683
  const accounts = JSON.parse(raw);
579
684
  for (const user of Object.values(accounts)) {
580
685
  const conns = Array.isArray(user?.storage_connections) ? user.storage_connections : [];
@@ -2144,39 +2249,13 @@ async function fetchCloudflareData(payload, rawUserId, env) {
2144
2249
  usageMetrics: unifiedMetrics,
2145
2250
  unifiedMetrics
2146
2251
  };
2147
- } catch (err) {
2148
- try {
2149
- const srklUrl = await getPrimarySrklDeploymentUrl2(env);
2150
- const srklRes = await fetch(`${srklUrl}/api/resources`, {
2151
- headers: {
2152
- "x-service-id": "cloudflare",
2153
- authorization: `Bearer ${token}`,
2154
- "x-cf-account-id": accountTag
2155
- },
2156
- signal: AbortSignal.timeout(6e3)
2157
- });
2158
- if (srklRes.ok) {
2159
- const sData = await srklRes.json();
2160
- if (sData.success && Array.isArray(sData.resources)) {
2161
- const projs = sData.resources.map((r) => ({
2162
- id: r.id || r.name,
2163
- name: r.name,
2164
- type: r.type,
2165
- status: r.status || "ONLINE",
2166
- framework: r.type === "PAGES_PROJECT" ? "Cloudflare Pages" : "Cloudflare Worker",
2167
- domain: r.subdomain ? `${r.subdomain}.pages.dev` : r.url ? r.url.replace(/^https?:\/\//, "") : `${r.name}.workers.dev`,
2168
- domains: r.routes || [r.url || `${r.name}.workers.dev`],
2169
- url: r.url || `https://${r.name}.workers.dev`,
2170
- edgeRequestsFormatted: "0",
2171
- fastDataTransferFormatted: "0 MB",
2172
- updatedAt: r.updatedAt
2173
- }));
2174
- return { success: true, provider: "CLOUDFLARE", tier: "free", isFree: true, accountName: accountName || void 0, accountId: accountTag, projectsCount: projs.length, projects: projs, projectObservability: projs.map((p) => ({ ...p, projectId: p.id, projectName: p.name, deploymentUrl: p.url, latestDeploymentUrl: p.url })), workers: projs.filter((p) => p.type === "WORKER"), pages: projs.filter((p) => p.type === "PAGES_PROJECT") };
2175
- }
2176
- }
2177
- } catch {
2178
- }
2179
- return { success: false, error: err.message || "Failed to query Cloudflare API.", projects: [], projectObservability: [] };
2252
+ } catch {
2253
+ return {
2254
+ success: false,
2255
+ error: "Cloudflare API request failed. Check token permissions and account configuration.",
2256
+ projects: [],
2257
+ projectObservability: []
2258
+ };
2180
2259
  }
2181
2260
  }
2182
2261
 
@@ -2596,8 +2675,8 @@ function createWavBuffer(sampleRate, numChannels, samples) {
2596
2675
  }
2597
2676
 
2598
2677
  // src/server/sampleGenerator.ts
2599
- import fs2 from "fs";
2600
- import path2 from "path";
2678
+ import fs3 from "fs";
2679
+ import path3 from "path";
2601
2680
  var GLOBAL_SAMPLE_DEFS = [
2602
2681
  {
2603
2682
  filename: "808_sub_boom.wav",
@@ -2694,13 +2773,13 @@ var GLOBAL_SAMPLE_DEFS = [
2694
2773
  }
2695
2774
  ];
2696
2775
  async function ensureGlobalSamples(globalSamplesDir) {
2697
- if (!fs2.existsSync(globalSamplesDir)) {
2698
- fs2.mkdirSync(globalSamplesDir, { recursive: true });
2776
+ if (!fs3.existsSync(globalSamplesDir)) {
2777
+ fs3.mkdirSync(globalSamplesDir, { recursive: true });
2699
2778
  }
2700
2779
  const sampleRate = 44100;
2701
2780
  for (const def of GLOBAL_SAMPLE_DEFS) {
2702
- const filePath = path2.join(globalSamplesDir, def.filename);
2703
- if (!fs2.existsSync(filePath)) {
2781
+ const filePath = path3.join(globalSamplesDir, def.filename);
2782
+ if (!fs3.existsSync(filePath)) {
2704
2783
  const numSamples = Math.floor(sampleRate * def.durationSec);
2705
2784
  const chL = new Float32Array(numSamples);
2706
2785
  const chR = new Float32Array(numSamples);
@@ -2712,16 +2791,16 @@ async function ensureGlobalSamples(globalSamplesDir) {
2712
2791
  chR[i] = r;
2713
2792
  }
2714
2793
  const wavBuf = createWavBuffer(sampleRate, 2, [chL, chR]);
2715
- await fs2.promises.writeFile(filePath, wavBuf);
2794
+ await fs3.promises.writeFile(filePath, wavBuf);
2716
2795
  }
2717
2796
  }
2718
2797
  }
2719
2798
 
2720
2799
  // src/server/services/assetPoolService.ts
2721
- import fs3 from "fs";
2722
- import path3 from "path";
2723
- var WORKSPACE_ASSETS_ROOT = path3.join(process.cwd(), "assets");
2724
- var PROJECTS_ROOT = path3.join(process.cwd(), "projects");
2800
+ import fs4 from "fs";
2801
+ import path4 from "path";
2802
+ var WORKSPACE_ASSETS_ROOT = path4.join(process.cwd(), "assets");
2803
+ var PROJECTS_ROOT = path4.join(process.cwd(), "projects");
2725
2804
  var SUPPORTED_AUDIO_EXTS = [
2726
2805
  ".wav",
2727
2806
  ".mp3",
@@ -2739,27 +2818,27 @@ var SUPPORTED_AUDIO_EXTS = [
2739
2818
  var SUPPORTED_MIDI_EXTS = [".mid", ".midi", ".json"];
2740
2819
  async function ensureAssetPoolDirectories(rootDir) {
2741
2820
  const dirs = [
2742
- path3.join(rootDir, "audio", "stereo", "default"),
2743
- path3.join(rootDir, "audio", "stereo", "userdefined"),
2744
- path3.join(rootDir, "audio", "mono", "default"),
2745
- path3.join(rootDir, "audio", "mono", "userdefined"),
2746
- path3.join(rootDir, "midi", "default"),
2747
- path3.join(rootDir, "midi", "userdefined")
2821
+ path4.join(rootDir, "audio", "stereo", "default"),
2822
+ path4.join(rootDir, "audio", "stereo", "userdefined"),
2823
+ path4.join(rootDir, "audio", "mono", "default"),
2824
+ path4.join(rootDir, "audio", "mono", "userdefined"),
2825
+ path4.join(rootDir, "midi", "default"),
2826
+ path4.join(rootDir, "midi", "userdefined")
2748
2827
  ];
2749
2828
  for (const dir of dirs) {
2750
- if (!fs3.existsSync(dir)) {
2751
- await fs3.promises.mkdir(dir, { recursive: true });
2829
+ if (!fs4.existsSync(dir)) {
2830
+ await fs4.promises.mkdir(dir, { recursive: true });
2752
2831
  }
2753
2832
  }
2754
2833
  }
2755
2834
  async function seedDefaultAssets() {
2756
2835
  await ensureAssetPoolDirectories(WORKSPACE_ASSETS_ROOT);
2757
- const stereoDefaultDir = path3.join(WORKSPACE_ASSETS_ROOT, "audio", "stereo", "default");
2758
- const monoDefaultDir = path3.join(WORKSPACE_ASSETS_ROOT, "audio", "mono", "default");
2759
- const midiDefaultDir = path3.join(WORKSPACE_ASSETS_ROOT, "midi", "default");
2836
+ const stereoDefaultDir = path4.join(WORKSPACE_ASSETS_ROOT, "audio", "stereo", "default");
2837
+ const monoDefaultDir = path4.join(WORKSPACE_ASSETS_ROOT, "audio", "mono", "default");
2838
+ const midiDefaultDir = path4.join(WORKSPACE_ASSETS_ROOT, "midi", "default");
2760
2839
  const sampleRate = 44100;
2761
- const subBoomPath = path3.join(stereoDefaultDir, "808_sub_boom.wav");
2762
- if (!fs3.existsSync(subBoomPath)) {
2840
+ const subBoomPath = path4.join(stereoDefaultDir, "808_sub_boom.wav");
2841
+ if (!fs4.existsSync(subBoomPath)) {
2763
2842
  const numSamples = Math.floor(sampleRate * 1.8);
2764
2843
  const chL = new Float32Array(numSamples);
2765
2844
  const chR = new Float32Array(numSamples);
@@ -2770,10 +2849,10 @@ async function seedDefaultAssets() {
2770
2849
  chL[i] = s;
2771
2850
  chR[i] = s;
2772
2851
  }
2773
- await fs3.promises.writeFile(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
2852
+ await fs4.promises.writeFile(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
2774
2853
  }
2775
- const leadPath = path3.join(stereoDefaultDir, "celestial_lead.wav");
2776
- if (!fs3.existsSync(leadPath)) {
2854
+ const leadPath = path4.join(stereoDefaultDir, "celestial_lead.wav");
2855
+ if (!fs4.existsSync(leadPath)) {
2777
2856
  const numSamples = Math.floor(sampleRate * 2.5);
2778
2857
  const chL = new Float32Array(numSamples);
2779
2858
  const chR = new Float32Array(numSamples);
@@ -2787,10 +2866,10 @@ async function seedDefaultAssets() {
2787
2866
  chL[i] = s1 * env;
2788
2867
  chR[i] = (s1 + s2 * 0.5) * env;
2789
2868
  }
2790
- await fs3.promises.writeFile(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
2869
+ await fs4.promises.writeFile(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
2791
2870
  }
2792
- const padPath = path3.join(stereoDefaultDir, "ethereal_pad.wav");
2793
- if (!fs3.existsSync(padPath)) {
2871
+ const padPath = path4.join(stereoDefaultDir, "ethereal_pad.wav");
2872
+ if (!fs4.existsSync(padPath)) {
2794
2873
  const numSamples = Math.floor(sampleRate * 3);
2795
2874
  const chL = new Float32Array(numSamples);
2796
2875
  const chR = new Float32Array(numSamples);
@@ -2809,10 +2888,10 @@ async function seedDefaultAssets() {
2809
2888
  chL[i] = left * env;
2810
2889
  chR[i] = right * env;
2811
2890
  }
2812
- await fs3.promises.writeFile(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
2891
+ await fs4.promises.writeFile(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
2813
2892
  }
2814
- const snarePath = path3.join(monoDefaultDir, "snare_snappy.wav");
2815
- if (!fs3.existsSync(snarePath)) {
2893
+ const snarePath = path4.join(monoDefaultDir, "snare_snappy.wav");
2894
+ if (!fs4.existsSync(snarePath)) {
2816
2895
  const numSamples = Math.floor(sampleRate * 0.8);
2817
2896
  const chM = new Float32Array(numSamples);
2818
2897
  for (let i = 0; i < numSamples; i++) {
@@ -2822,10 +2901,10 @@ async function seedDefaultAssets() {
2822
2901
  const noise = (Math.random() * 2 - 1) * Math.exp(-p * 4.5) * 0.6;
2823
2902
  chM[i] = tone + noise;
2824
2903
  }
2825
- await fs3.promises.writeFile(snarePath, createWavBuffer(sampleRate, 1, [chM]));
2904
+ await fs4.promises.writeFile(snarePath, createWavBuffer(sampleRate, 1, [chM]));
2826
2905
  }
2827
- const hihatPath = path3.join(monoDefaultDir, "hihat_closed.wav");
2828
- if (!fs3.existsSync(hihatPath)) {
2906
+ const hihatPath = path4.join(monoDefaultDir, "hihat_closed.wav");
2907
+ if (!fs4.existsSync(hihatPath)) {
2829
2908
  const numSamples = Math.floor(sampleRate * 0.25);
2830
2909
  const chM = new Float32Array(numSamples);
2831
2910
  for (let i = 0; i < numSamples; i++) {
@@ -2833,10 +2912,10 @@ async function seedDefaultAssets() {
2833
2912
  const noise = (Math.random() * 2 - 1) * Math.exp(-p * 20);
2834
2913
  chM[i] = noise * 0.5;
2835
2914
  }
2836
- await fs3.promises.writeFile(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
2915
+ await fs4.promises.writeFile(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
2837
2916
  }
2838
- const midiChordPath = path3.join(midiDefaultDir, "lydian_celestial_pad.json");
2839
- if (!fs3.existsSync(midiChordPath)) {
2917
+ const midiChordPath = path4.join(midiDefaultDir, "lydian_celestial_pad.json");
2918
+ if (!fs4.existsSync(midiChordPath)) {
2840
2919
  const starterMidiPattern = {
2841
2920
  id: "pat-default-lydian",
2842
2921
  name: "Lydian Celestial Pad",
@@ -2849,31 +2928,31 @@ async function seedDefaultAssets() {
2849
2928
  { note: 71, name: "B4", velocity: 0.75, time: 0, duration: 3.8 }
2850
2929
  ]
2851
2930
  };
2852
- await fs3.promises.writeFile(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
2931
+ await fs4.promises.writeFile(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
2853
2932
  }
2854
2933
  await ensureProjectAssets("default-kingdom");
2855
2934
  }
2856
2935
  async function ensureProjectAssets(projectId) {
2857
- const safeId = path3.basename(projectId);
2858
- const projectAssetsDir = path3.join(PROJECTS_ROOT, safeId, "assets");
2936
+ const safeId = path4.basename(projectId);
2937
+ const projectAssetsDir = path4.join(PROJECTS_ROOT, safeId, "assets");
2859
2938
  await ensureAssetPoolDirectories(projectAssetsDir);
2860
2939
  return projectAssetsDir;
2861
2940
  }
2862
2941
  function getAssetPoolLocationPath(scope, projectId, dataType, channelType, subfolder = "userdefined") {
2863
- const root = scope === "project" && projectId ? path3.join(PROJECTS_ROOT, path3.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
2864
- const safeSub = path3.basename(subfolder).replace(/[^a-zA-Z0-9._-]/g, "_");
2942
+ const root = scope === "project" && projectId ? path4.join(PROJECTS_ROOT, path4.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
2943
+ const safeSub = path4.basename(subfolder).replace(/[^a-zA-Z0-9._-]/g, "_");
2865
2944
  if (dataType === "audio") {
2866
2945
  const safeChannel = channelType === "mono" ? "mono" : "stereo";
2867
- return path3.join(root, "audio", safeChannel, safeSub);
2946
+ return path4.join(root, "audio", safeChannel, safeSub);
2868
2947
  } else {
2869
- return path3.join(root, "midi", safeSub);
2948
+ return path4.join(root, "midi", safeSub);
2870
2949
  }
2871
2950
  }
2872
2951
  function getAssetPoolPublicUrl(scope, projectId, dataType, channelType, subfolder, filename) {
2873
- const safeFilename = path3.basename(filename);
2874
- const safeSub = path3.basename(subfolder);
2952
+ const safeFilename = path4.basename(filename);
2953
+ const safeSub = path4.basename(subfolder);
2875
2954
  if (scope === "project" && projectId) {
2876
- const safeProj = path3.basename(projectId);
2955
+ const safeProj = path4.basename(projectId);
2877
2956
  if (dataType === "audio") {
2878
2957
  const channel = channelType === "mono" ? "mono" : "stereo";
2879
2958
  return `/projects/${safeProj}/assets/audio/${channel}/${safeSub}/${safeFilename}`;
@@ -2895,31 +2974,31 @@ async function scanAssetPool(scope, projectId) {
2895
2974
  } else {
2896
2975
  await ensureAssetPoolDirectories(WORKSPACE_ASSETS_ROOT);
2897
2976
  }
2898
- const rootDir = scope === "project" && projectId ? path3.join(PROJECTS_ROOT, path3.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
2977
+ const rootDir = scope === "project" && projectId ? path4.join(PROJECTS_ROOT, path4.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
2899
2978
  const folders = [];
2900
2979
  const items = [];
2901
2980
  async function scanCategoryFolder(dataType, channelType) {
2902
- const catDir = dataType === "audio" ? path3.join(rootDir, "audio", channelType === "mono" ? "mono" : "stereo") : path3.join(rootDir, "midi");
2903
- if (!fs3.existsSync(catDir)) {
2904
- await fs3.promises.mkdir(catDir, { recursive: true });
2981
+ const catDir = dataType === "audio" ? path4.join(rootDir, "audio", channelType === "mono" ? "mono" : "stereo") : path4.join(rootDir, "midi");
2982
+ if (!fs4.existsSync(catDir)) {
2983
+ await fs4.promises.mkdir(catDir, { recursive: true });
2905
2984
  }
2906
- const subentries = await fs3.promises.readdir(catDir, { withFileTypes: true });
2985
+ const subentries = await fs4.promises.readdir(catDir, { withFileTypes: true });
2907
2986
  for (const entry of subentries) {
2908
2987
  if (!entry.isDirectory()) continue;
2909
2988
  const subfolderName = entry.name;
2910
- const subfolderDir = path3.join(catDir, subfolderName);
2911
- const files = await fs3.promises.readdir(subfolderDir);
2989
+ const subfolderDir = path4.join(catDir, subfolderName);
2990
+ const files = await fs4.promises.readdir(subfolderDir);
2912
2991
  let validFileCount = 0;
2913
2992
  for (const file of files) {
2914
2993
  if (file.startsWith(".")) continue;
2915
- const ext = path3.extname(file).toLowerCase();
2994
+ const ext = path4.extname(file).toLowerCase();
2916
2995
  const isAudio = SUPPORTED_AUDIO_EXTS.includes(ext);
2917
2996
  const isMidi = SUPPORTED_MIDI_EXTS.includes(ext);
2918
2997
  if (dataType === "audio" && !isAudio || dataType === "midi" && !isMidi) continue;
2919
2998
  validFileCount++;
2920
- const filePath = path3.join(subfolderDir, file);
2921
- const stat = await fs3.promises.stat(filePath);
2922
- const cleanName = path3.basename(file, ext).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
2999
+ const filePath = path4.join(subfolderDir, file);
3000
+ const stat = await fs4.promises.stat(filePath);
3001
+ const cleanName = path4.basename(file, ext).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
2923
3002
  const relPath = dataType === "audio" ? `audio/${channelType === "mono" ? "mono" : "stereo"}/${subfolderName}/${file}` : `midi/${subfolderName}/${file}`;
2924
3003
  const url = getAssetPoolPublicUrl(
2925
3004
  scope,
@@ -2960,7 +3039,7 @@ async function scanAssetPool(scope, projectId) {
2960
3039
  return { folders, items };
2961
3040
  }
2962
3041
  async function createAssetSubfolder(params) {
2963
- const safeName = path3.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
3042
+ const safeName = path4.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
2964
3043
  if (!safeName) throw new Error("Invalid subfolder name");
2965
3044
  const dirPath = getAssetPoolLocationPath(
2966
3045
  params.scope,
@@ -2969,8 +3048,8 @@ async function createAssetSubfolder(params) {
2969
3048
  params.channelType,
2970
3049
  safeName
2971
3050
  );
2972
- if (!fs3.existsSync(dirPath)) {
2973
- await fs3.promises.mkdir(dirPath, { recursive: true });
3051
+ if (!fs4.existsSync(dirPath)) {
3052
+ await fs4.promises.mkdir(dirPath, { recursive: true });
2974
3053
  }
2975
3054
  return {
2976
3055
  name: safeName,
@@ -2989,16 +3068,16 @@ async function saveAssetToPool(params) {
2989
3068
  params.channelType,
2990
3069
  subfolder
2991
3070
  );
2992
- if (!fs3.existsSync(targetDir)) {
2993
- await fs3.promises.mkdir(targetDir, { recursive: true });
3071
+ if (!fs4.existsSync(targetDir)) {
3072
+ await fs4.promises.mkdir(targetDir, { recursive: true });
2994
3073
  }
2995
- const safeFilename = path3.basename(params.filename).replace(/[^a-zA-Z0-9._-]/g, "_");
2996
- const ext = path3.extname(safeFilename).toLowerCase() || (params.dataType === "audio" ? ".wav" : ".json");
2997
- const filePath = path3.join(targetDir, safeFilename);
3074
+ const safeFilename = path4.basename(params.filename).replace(/[^a-zA-Z0-9._-]/g, "_");
3075
+ const ext = path4.extname(safeFilename).toLowerCase() || (params.dataType === "audio" ? ".wav" : ".json");
3076
+ const filePath = path4.join(targetDir, safeFilename);
2998
3077
  const buffer = Buffer.from(params.base64Content, "base64");
2999
- await fs3.promises.writeFile(filePath, buffer);
3000
- const stat = await fs3.promises.stat(filePath);
3001
- const cleanName = path3.basename(safeFilename, ext).replace(/[-_]/g, " ");
3078
+ await fs4.promises.writeFile(filePath, buffer);
3079
+ const stat = await fs4.promises.stat(filePath);
3080
+ const cleanName = path4.basename(safeFilename, ext).replace(/[-_]/g, " ");
3002
3081
  const relPath = params.dataType === "audio" ? `audio/${params.channelType === "mono" ? "mono" : "stereo"}/${subfolder}/${safeFilename}` : `midi/${subfolder}/${safeFilename}`;
3003
3082
  const url = getAssetPoolPublicUrl(
3004
3083
  params.scope,
@@ -3032,19 +3111,19 @@ async function deleteAssetFromPool(params) {
3032
3111
  params.channelType,
3033
3112
  params.subfolder
3034
3113
  );
3035
- const filePath = path3.join(targetDir, path3.basename(params.filename));
3036
- if (fs3.existsSync(filePath)) {
3037
- await fs3.promises.unlink(filePath);
3114
+ const filePath = path4.join(targetDir, path4.basename(params.filename));
3115
+ if (fs4.existsSync(filePath)) {
3116
+ await fs4.promises.unlink(filePath);
3038
3117
  return true;
3039
3118
  }
3040
3119
  return false;
3041
3120
  }
3042
3121
 
3043
3122
  // src/server/services/graphAssetService.ts
3044
- import fs4 from "fs";
3045
- import path4 from "path";
3046
- var WORKSPACE_ROOT = path4.join(process.cwd(), "workspaces", "default");
3047
- var GRAPHS_ROOT = path4.join(WORKSPACE_ROOT, "graphs");
3123
+ import fs5 from "fs";
3124
+ import path5 from "path";
3125
+ var WORKSPACE_ROOT = path5.join(process.cwd(), "workspaces", "default");
3126
+ var GRAPHS_ROOT = path5.join(WORKSPACE_ROOT, "graphs");
3048
3127
  var SUPPORTED_AUDIO_EXTS2 = [
3049
3128
  ".wav",
3050
3129
  ".mp3",
@@ -3062,26 +3141,26 @@ var SUPPORTED_AUDIO_EXTS2 = [
3062
3141
  var SUPPORTED_MIDI_EXTS2 = [".mid", ".midi", ".json"];
3063
3142
  function ensureGraphAssetDirectories(graphDir) {
3064
3143
  const dirs = [
3065
- path4.join(graphDir, "assets", "audio", "stereo", "default"),
3066
- path4.join(graphDir, "assets", "audio", "stereo", "userdefined"),
3067
- path4.join(graphDir, "assets", "audio", "mono", "default"),
3068
- path4.join(graphDir, "assets", "audio", "mono", "userdefined"),
3069
- path4.join(graphDir, "assets", "midi", "default"),
3070
- path4.join(graphDir, "assets", "midi", "userdefined")
3144
+ path5.join(graphDir, "assets", "audio", "stereo", "default"),
3145
+ path5.join(graphDir, "assets", "audio", "stereo", "userdefined"),
3146
+ path5.join(graphDir, "assets", "audio", "mono", "default"),
3147
+ path5.join(graphDir, "assets", "audio", "mono", "userdefined"),
3148
+ path5.join(graphDir, "assets", "midi", "default"),
3149
+ path5.join(graphDir, "assets", "midi", "userdefined")
3071
3150
  ];
3072
3151
  for (const dir of dirs) {
3073
- if (!fs4.existsSync(dir)) {
3074
- fs4.mkdirSync(dir, { recursive: true });
3152
+ if (!fs5.existsSync(dir)) {
3153
+ fs5.mkdirSync(dir, { recursive: true });
3075
3154
  }
3076
3155
  }
3077
3156
  }
3078
3157
  function seedStarterGraphAssets(graphDir) {
3079
- const stereoDefaultDir = path4.join(graphDir, "assets", "audio", "stereo", "default");
3080
- const monoDefaultDir = path4.join(graphDir, "assets", "audio", "mono", "default");
3081
- const midiDefaultDir = path4.join(graphDir, "assets", "midi", "default");
3158
+ const stereoDefaultDir = path5.join(graphDir, "assets", "audio", "stereo", "default");
3159
+ const monoDefaultDir = path5.join(graphDir, "assets", "audio", "mono", "default");
3160
+ const midiDefaultDir = path5.join(graphDir, "assets", "midi", "default");
3082
3161
  const sampleRate = 44100;
3083
- const subBoomPath = path4.join(stereoDefaultDir, "808_sub_boom.wav");
3084
- if (!fs4.existsSync(subBoomPath)) {
3162
+ const subBoomPath = path5.join(stereoDefaultDir, "808_sub_boom.wav");
3163
+ if (!fs5.existsSync(subBoomPath)) {
3085
3164
  const numSamples = Math.floor(sampleRate * 1.8);
3086
3165
  const chL = new Float32Array(numSamples);
3087
3166
  const chR = new Float32Array(numSamples);
@@ -3092,10 +3171,10 @@ function seedStarterGraphAssets(graphDir) {
3092
3171
  chL[i] = s;
3093
3172
  chR[i] = s;
3094
3173
  }
3095
- fs4.writeFileSync(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
3174
+ fs5.writeFileSync(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
3096
3175
  }
3097
- const leadPath = path4.join(stereoDefaultDir, "celestial_lead.wav");
3098
- if (!fs4.existsSync(leadPath)) {
3176
+ const leadPath = path5.join(stereoDefaultDir, "celestial_lead.wav");
3177
+ if (!fs5.existsSync(leadPath)) {
3099
3178
  const numSamples = Math.floor(sampleRate * 2.5);
3100
3179
  const chL = new Float32Array(numSamples);
3101
3180
  const chR = new Float32Array(numSamples);
@@ -3109,10 +3188,10 @@ function seedStarterGraphAssets(graphDir) {
3109
3188
  chL[i] = s1 * env;
3110
3189
  chR[i] = (s1 + s2 * 0.5) * env;
3111
3190
  }
3112
- fs4.writeFileSync(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
3191
+ fs5.writeFileSync(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
3113
3192
  }
3114
- const padPath = path4.join(stereoDefaultDir, "ethereal_pad.wav");
3115
- if (!fs4.existsSync(padPath)) {
3193
+ const padPath = path5.join(stereoDefaultDir, "ethereal_pad.wav");
3194
+ if (!fs5.existsSync(padPath)) {
3116
3195
  const numSamples = Math.floor(sampleRate * 3);
3117
3196
  const chL = new Float32Array(numSamples);
3118
3197
  const chR = new Float32Array(numSamples);
@@ -3131,10 +3210,10 @@ function seedStarterGraphAssets(graphDir) {
3131
3210
  chL[i] = left * env;
3132
3211
  chR[i] = right * env;
3133
3212
  }
3134
- fs4.writeFileSync(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
3213
+ fs5.writeFileSync(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
3135
3214
  }
3136
- const snarePath = path4.join(monoDefaultDir, "snare_snappy.wav");
3137
- if (!fs4.existsSync(snarePath)) {
3215
+ const snarePath = path5.join(monoDefaultDir, "snare_snappy.wav");
3216
+ if (!fs5.existsSync(snarePath)) {
3138
3217
  const numSamples = Math.floor(sampleRate * 0.8);
3139
3218
  const chM = new Float32Array(numSamples);
3140
3219
  for (let i = 0; i < numSamples; i++) {
@@ -3144,10 +3223,10 @@ function seedStarterGraphAssets(graphDir) {
3144
3223
  const noise = (Math.random() * 2 - 1) * Math.exp(-p * 4.5) * 0.6;
3145
3224
  chM[i] = tone + noise;
3146
3225
  }
3147
- fs4.writeFileSync(snarePath, createWavBuffer(sampleRate, 1, [chM]));
3226
+ fs5.writeFileSync(snarePath, createWavBuffer(sampleRate, 1, [chM]));
3148
3227
  }
3149
- const hihatPath = path4.join(monoDefaultDir, "hihat_closed.wav");
3150
- if (!fs4.existsSync(hihatPath)) {
3228
+ const hihatPath = path5.join(monoDefaultDir, "hihat_closed.wav");
3229
+ if (!fs5.existsSync(hihatPath)) {
3151
3230
  const numSamples = Math.floor(sampleRate * 0.25);
3152
3231
  const chM = new Float32Array(numSamples);
3153
3232
  for (let i = 0; i < numSamples; i++) {
@@ -3155,10 +3234,10 @@ function seedStarterGraphAssets(graphDir) {
3155
3234
  const noise = (Math.random() * 2 - 1) * Math.exp(-p * 20);
3156
3235
  chM[i] = noise * 0.5;
3157
3236
  }
3158
- fs4.writeFileSync(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
3237
+ fs5.writeFileSync(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
3159
3238
  }
3160
- const midiChordPath = path4.join(midiDefaultDir, "lydian_celestial_pad.json");
3161
- if (!fs4.existsSync(midiChordPath)) {
3239
+ const midiChordPath = path5.join(midiDefaultDir, "lydian_celestial_pad.json");
3240
+ if (!fs5.existsSync(midiChordPath)) {
3162
3241
  const starterMidiPattern = {
3163
3242
  id: "pat-default-lydian",
3164
3243
  name: "Lydian Celestial Pad",
@@ -3171,43 +3250,43 @@ function seedStarterGraphAssets(graphDir) {
3171
3250
  { note: 71, name: "B4", velocity: 0.75, time: 0, duration: 3.8 }
3172
3251
  ]
3173
3252
  };
3174
- fs4.writeFileSync(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
3253
+ fs5.writeFileSync(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
3175
3254
  }
3176
3255
  }
3177
3256
  async function scanGraphAssets(graphId, includeImported = true) {
3178
- const safeGraphId = path4.basename(graphId);
3179
- const graphDir = path4.join(GRAPHS_ROOT, safeGraphId);
3180
- if (!fs4.existsSync(graphDir)) {
3181
- await fs4.promises.mkdir(graphDir, { recursive: true });
3257
+ const safeGraphId = path5.basename(graphId);
3258
+ const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
3259
+ if (!fs5.existsSync(graphDir)) {
3260
+ await fs5.promises.mkdir(graphDir, { recursive: true });
3182
3261
  }
3183
3262
  ensureGraphAssetDirectories(graphDir);
3184
3263
  const folders = [];
3185
3264
  const items = [];
3186
3265
  const importedItems = [];
3187
3266
  async function scanSingleGraph(gId, isImported, ownerName) {
3188
- const currentGraphDir = path4.join(GRAPHS_ROOT, path4.basename(gId));
3189
- const assetsDir = path4.join(currentGraphDir, "assets");
3190
- if (!fs4.existsSync(assetsDir)) return;
3267
+ const currentGraphDir = path5.join(GRAPHS_ROOT, path5.basename(gId));
3268
+ const assetsDir = path5.join(currentGraphDir, "assets");
3269
+ if (!fs5.existsSync(assetsDir)) return;
3191
3270
  async function scanCategoryFolder(dataType, channelType) {
3192
- const catDir = dataType === "audio" ? path4.join(assetsDir, "audio", channelType === "mono" ? "mono" : "stereo") : path4.join(assetsDir, "midi");
3193
- if (!fs4.existsSync(catDir)) return;
3194
- const subentries = await fs4.promises.readdir(catDir, { withFileTypes: true });
3271
+ const catDir = dataType === "audio" ? path5.join(assetsDir, "audio", channelType === "mono" ? "mono" : "stereo") : path5.join(assetsDir, "midi");
3272
+ if (!fs5.existsSync(catDir)) return;
3273
+ const subentries = await fs5.promises.readdir(catDir, { withFileTypes: true });
3195
3274
  for (const entry of subentries) {
3196
3275
  if (!entry.isDirectory()) continue;
3197
3276
  const subfolderName = entry.name;
3198
- const subfolderDir = path4.join(catDir, subfolderName);
3199
- const files = await fs4.promises.readdir(subfolderDir);
3277
+ const subfolderDir = path5.join(catDir, subfolderName);
3278
+ const files = await fs5.promises.readdir(subfolderDir);
3200
3279
  let validFileCount = 0;
3201
3280
  for (const file of files) {
3202
3281
  if (file.startsWith(".")) continue;
3203
- const ext = path4.extname(file).toLowerCase();
3282
+ const ext = path5.extname(file).toLowerCase();
3204
3283
  const isAudio = SUPPORTED_AUDIO_EXTS2.includes(ext);
3205
3284
  const isMidi = SUPPORTED_MIDI_EXTS2.includes(ext);
3206
3285
  if (dataType === "audio" && !isAudio || dataType === "midi" && !isMidi) continue;
3207
3286
  validFileCount++;
3208
- const filePath = path4.join(subfolderDir, file);
3209
- const stat = await fs4.promises.stat(filePath);
3210
- const cleanName = path4.basename(file, ext).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
3287
+ const filePath = path5.join(subfolderDir, file);
3288
+ const stat = await fs5.promises.stat(filePath);
3289
+ const cleanName = path5.basename(file, ext).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
3211
3290
  const relPath = dataType === "audio" ? `audio/${channelType === "mono" ? "mono" : "stereo"}/${subfolderName}/${file}` : `midi/${subfolderName}/${file}`;
3212
3291
  const url = dataType === "audio" ? `/graphs/${gId}/assets/audio/${channelType === "mono" ? "mono" : "stereo"}/${subfolderName}/${file}` : `/graphs/${gId}/assets/midi/${subfolderName}/${file}`;
3213
3292
  const item = {
@@ -3250,18 +3329,18 @@ async function scanGraphAssets(graphId, includeImported = true) {
3250
3329
  }
3251
3330
  await scanSingleGraph(safeGraphId, false);
3252
3331
  if (includeImported) {
3253
- const qmsFile = path4.join(graphDir, "graph.qms");
3254
- if (fs4.existsSync(qmsFile)) {
3332
+ const qmsFile = path5.join(graphDir, "graph.qms");
3333
+ if (fs5.existsSync(qmsFile)) {
3255
3334
  try {
3256
- const raw = await fs4.promises.readFile(qmsFile, "utf-8");
3335
+ const raw = await fs5.promises.readFile(qmsFile, "utf-8");
3257
3336
  const pkg = JSON.parse(raw);
3258
3337
  const importedIds = pkg?.metadata?.importedGraphIds || [];
3259
3338
  for (const impId of importedIds) {
3260
- const impQms = path4.join(GRAPHS_ROOT, impId, "graph.qms");
3339
+ const impQms = path5.join(GRAPHS_ROOT, impId, "graph.qms");
3261
3340
  let impName = impId;
3262
- if (fs4.existsSync(impQms)) {
3341
+ if (fs5.existsSync(impQms)) {
3263
3342
  try {
3264
- const impRaw = await fs4.promises.readFile(impQms, "utf-8");
3343
+ const impRaw = await fs5.promises.readFile(impQms, "utf-8");
3265
3344
  const impPkg = JSON.parse(impRaw);
3266
3345
  impName = impPkg?.metadata?.name || impId;
3267
3346
  } catch {
@@ -3277,14 +3356,14 @@ async function scanGraphAssets(graphId, includeImported = true) {
3277
3356
  return { folders, items, importedItems };
3278
3357
  }
3279
3358
  async function createGraphAssetFolder(params) {
3280
- const safeGraphId = path4.basename(params.graphId);
3281
- const safeFolderName = path4.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
3359
+ const safeGraphId = path5.basename(params.graphId);
3360
+ const safeFolderName = path5.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
3282
3361
  if (!safeFolderName) throw new Error("Invalid subfolder name");
3283
- const graphDir = path4.join(GRAPHS_ROOT, safeGraphId);
3362
+ const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
3284
3363
  ensureGraphAssetDirectories(graphDir);
3285
- const targetDir = params.dataType === "audio" ? path4.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", safeFolderName) : path4.join(graphDir, "assets", "midi", safeFolderName);
3286
- if (!fs4.existsSync(targetDir)) {
3287
- await fs4.promises.mkdir(targetDir, { recursive: true });
3364
+ const targetDir = params.dataType === "audio" ? path5.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", safeFolderName) : path5.join(graphDir, "assets", "midi", safeFolderName);
3365
+ if (!fs5.existsSync(targetDir)) {
3366
+ await fs5.promises.mkdir(targetDir, { recursive: true });
3288
3367
  }
3289
3368
  return {
3290
3369
  name: safeFolderName,
@@ -3296,21 +3375,21 @@ async function createGraphAssetFolder(params) {
3296
3375
  };
3297
3376
  }
3298
3377
  async function saveAssetToGraph(params) {
3299
- const safeGraphId = path4.basename(params.graphId);
3378
+ const safeGraphId = path5.basename(params.graphId);
3300
3379
  const subfolder = params.subfolder || "userdefined";
3301
- const graphDir = path4.join(GRAPHS_ROOT, safeGraphId);
3380
+ const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
3302
3381
  ensureGraphAssetDirectories(graphDir);
3303
- const targetDir = params.dataType === "audio" ? path4.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", subfolder) : path4.join(graphDir, "assets", "midi", subfolder);
3304
- if (!fs4.existsSync(targetDir)) {
3305
- await fs4.promises.mkdir(targetDir, { recursive: true });
3382
+ const targetDir = params.dataType === "audio" ? path5.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", subfolder) : path5.join(graphDir, "assets", "midi", subfolder);
3383
+ if (!fs5.existsSync(targetDir)) {
3384
+ await fs5.promises.mkdir(targetDir, { recursive: true });
3306
3385
  }
3307
- const safeFilename = path4.basename(params.filename).replace(/[^a-zA-Z0-9._-]/g, "_");
3308
- const ext = path4.extname(safeFilename).toLowerCase() || (params.dataType === "audio" ? ".wav" : ".json");
3309
- const filePath = path4.join(targetDir, safeFilename);
3386
+ const safeFilename = path5.basename(params.filename).replace(/[^a-zA-Z0-9._-]/g, "_");
3387
+ const ext = path5.extname(safeFilename).toLowerCase() || (params.dataType === "audio" ? ".wav" : ".json");
3388
+ const filePath = path5.join(targetDir, safeFilename);
3310
3389
  const buffer = Buffer.from(params.base64Content, "base64");
3311
- await fs4.promises.writeFile(filePath, buffer);
3312
- const stat = await fs4.promises.stat(filePath);
3313
- const cleanName = path4.basename(safeFilename, ext).replace(/[-_]/g, " ");
3390
+ await fs5.promises.writeFile(filePath, buffer);
3391
+ const stat = await fs5.promises.stat(filePath);
3392
+ const cleanName = path5.basename(safeFilename, ext).replace(/[-_]/g, " ");
3314
3393
  const relPath = params.dataType === "audio" ? `audio/${params.channelType === "mono" ? "mono" : "stereo"}/${subfolder}/${safeFilename}` : `midi/${subfolder}/${safeFilename}`;
3315
3394
  const url = params.dataType === "audio" ? `/graphs/${safeGraphId}/assets/audio/${params.channelType === "mono" ? "mono" : "stereo"}/${subfolder}/${safeFilename}` : `/graphs/${safeGraphId}/assets/midi/${subfolder}/${safeFilename}`;
3316
3395
  return {
@@ -3329,32 +3408,32 @@ async function saveAssetToGraph(params) {
3329
3408
  };
3330
3409
  }
3331
3410
  async function deleteAssetFromGraph(params) {
3332
- const safeGraphId = path4.basename(params.graphId);
3333
- const graphDir = path4.join(GRAPHS_ROOT, safeGraphId);
3334
- const targetDir = params.dataType === "audio" ? path4.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", params.subfolder) : path4.join(graphDir, "assets", "midi", params.subfolder);
3335
- const filePath = path4.join(targetDir, path4.basename(params.filename));
3336
- if (fs4.existsSync(filePath)) {
3337
- await fs4.promises.unlink(filePath);
3411
+ const safeGraphId = path5.basename(params.graphId);
3412
+ const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
3413
+ const targetDir = params.dataType === "audio" ? path5.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", params.subfolder) : path5.join(graphDir, "assets", "midi", params.subfolder);
3414
+ const filePath = path5.join(targetDir, path5.basename(params.filename));
3415
+ if (fs5.existsSync(filePath)) {
3416
+ await fs5.promises.unlink(filePath);
3338
3417
  return true;
3339
3418
  }
3340
3419
  return false;
3341
3420
  }
3342
3421
 
3343
3422
  // src/server/services/graphPackageService.ts
3344
- import fs5 from "fs";
3345
- import path5 from "path";
3423
+ import fs6 from "fs";
3424
+ import path6 from "path";
3346
3425
  import { validateGraphImport } from "@ultrst-armada/kloks/state-graph";
3347
- var WORKSPACE_ROOT2 = path5.join(process.cwd(), "workspaces", "default");
3348
- var GRAPHS_ROOT2 = path5.join(WORKSPACE_ROOT2, "graphs");
3349
- var LEGACY_PROJECTS_ROOT = path5.join(process.cwd(), "projects");
3426
+ var WORKSPACE_ROOT2 = path6.join(process.cwd(), "workspaces", "default");
3427
+ var GRAPHS_ROOT2 = path6.join(WORKSPACE_ROOT2, "graphs");
3428
+ var LEGACY_PROJECTS_ROOT = path6.join(process.cwd(), "projects");
3350
3429
  function ensureWorkspaceStructure() {
3351
- if (!fs5.existsSync(GRAPHS_ROOT2)) {
3352
- fs5.mkdirSync(GRAPHS_ROOT2, { recursive: true });
3430
+ if (!fs6.existsSync(GRAPHS_ROOT2)) {
3431
+ fs6.mkdirSync(GRAPHS_ROOT2, { recursive: true });
3353
3432
  }
3354
3433
  seedStarterGraphsIfEmpty();
3355
3434
  }
3356
3435
  function seedStarterGraphsIfEmpty() {
3357
- const existing = fs5.existsSync(GRAPHS_ROOT2) ? fs5.readdirSync(GRAPHS_ROOT2) : [];
3436
+ const existing = fs6.existsSync(GRAPHS_ROOT2) ? fs6.readdirSync(GRAPHS_ROOT2) : [];
3358
3437
  if (existing.length > 0) return;
3359
3438
  const introId = "intro-motif-starter";
3360
3439
  createInitialGraphPackageSync(
@@ -3623,9 +3702,9 @@ function seedStarterGraphsIfEmpty() {
3623
3702
  );
3624
3703
  }
3625
3704
  function createInitialGraphPackageSync(id, name, description, type, bpm, masterVolume, currentBiome, nodes, connections, importedGraphIds = []) {
3626
- const graphDir = path5.join(GRAPHS_ROOT2, id);
3627
- if (!fs5.existsSync(graphDir)) {
3628
- fs5.mkdirSync(graphDir, { recursive: true });
3705
+ const graphDir = path6.join(GRAPHS_ROOT2, id);
3706
+ if (!fs6.existsSync(graphDir)) {
3707
+ fs6.mkdirSync(graphDir, { recursive: true });
3629
3708
  }
3630
3709
  ensureGraphAssetDirectories(graphDir);
3631
3710
  seedStarterGraphAssets(graphDir);
@@ -3658,29 +3737,29 @@ function createInitialGraphPackageSync(id, name, description, type, bpm, masterV
3658
3737
  connections
3659
3738
  }
3660
3739
  };
3661
- fs5.writeFileSync(path5.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
3740
+ fs6.writeFileSync(path6.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
3662
3741
  }
3663
3742
  async function listAllGraphPackages() {
3664
3743
  ensureWorkspaceStructure();
3665
- const dirs = await fs5.promises.readdir(GRAPHS_ROOT2);
3744
+ const dirs = await fs6.promises.readdir(GRAPHS_ROOT2);
3666
3745
  const packages = [];
3667
3746
  for (const dir of dirs) {
3668
- const graphDir = path5.join(GRAPHS_ROOT2, dir);
3669
- const stat = await fs5.promises.stat(graphDir);
3747
+ const graphDir = path6.join(GRAPHS_ROOT2, dir);
3748
+ const stat = await fs6.promises.stat(graphDir);
3670
3749
  if (!stat.isDirectory()) continue;
3671
- const qmsFile = path5.join(graphDir, "graph.qms");
3672
- const legacyProjectFile = path5.join(graphDir, "project.json");
3750
+ const qmsFile = path6.join(graphDir, "graph.qms");
3751
+ const legacyProjectFile = path6.join(graphDir, "project.json");
3673
3752
  let packageData = null;
3674
- if (fs5.existsSync(qmsFile)) {
3753
+ if (fs6.existsSync(qmsFile)) {
3675
3754
  try {
3676
- const raw = await fs5.promises.readFile(qmsFile, "utf-8");
3755
+ const raw = await fs6.promises.readFile(qmsFile, "utf-8");
3677
3756
  packageData = JSON.parse(raw);
3678
3757
  } catch (err) {
3679
3758
  console.warn(`Corrupted graph.qms in ${dir}:`, err);
3680
3759
  }
3681
- } else if (fs5.existsSync(legacyProjectFile)) {
3760
+ } else if (fs6.existsSync(legacyProjectFile)) {
3682
3761
  try {
3683
- const raw = await fs5.promises.readFile(legacyProjectFile, "utf-8");
3762
+ const raw = await fs6.promises.readFile(legacyProjectFile, "utf-8");
3684
3763
  const legacy = JSON.parse(raw);
3685
3764
  packageData = {
3686
3765
  format: "qms_graph_package",
@@ -3710,7 +3789,7 @@ async function listAllGraphPackages() {
3710
3789
  mapIoConfig: legacy.mapIoConfig
3711
3790
  }
3712
3791
  };
3713
- await fs5.promises.writeFile(qmsFile, JSON.stringify(packageData, null, 2), "utf-8");
3792
+ await fs6.promises.writeFile(qmsFile, JSON.stringify(packageData, null, 2), "utf-8");
3714
3793
  } catch (err) {
3715
3794
  console.warn(`Failed to auto-migrate legacy project ${dir}:`, err);
3716
3795
  }
@@ -3732,13 +3811,13 @@ async function listAllGraphPackages() {
3732
3811
  }
3733
3812
  async function getGraphPackageById(id) {
3734
3813
  ensureWorkspaceStructure();
3735
- const safeId = path5.basename(id);
3736
- const graphDir = path5.join(GRAPHS_ROOT2, safeId);
3737
- const qmsFile = path5.join(graphDir, "graph.qms");
3738
- if (!fs5.existsSync(qmsFile)) {
3739
- const legacyProject = path5.join(LEGACY_PROJECTS_ROOT, safeId, "project.json");
3740
- if (fs5.existsSync(legacyProject)) {
3741
- const raw2 = await fs5.promises.readFile(legacyProject, "utf-8");
3814
+ const safeId = path6.basename(id);
3815
+ const graphDir = path6.join(GRAPHS_ROOT2, safeId);
3816
+ const qmsFile = path6.join(graphDir, "graph.qms");
3817
+ if (!fs6.existsSync(qmsFile)) {
3818
+ const legacyProject = path6.join(LEGACY_PROJECTS_ROOT, safeId, "project.json");
3819
+ if (fs6.existsSync(legacyProject)) {
3820
+ const raw2 = await fs6.promises.readFile(legacyProject, "utf-8");
3742
3821
  const legacy = JSON.parse(raw2);
3743
3822
  return {
3744
3823
  format: "qms_graph_package",
@@ -3771,7 +3850,7 @@ async function getGraphPackageById(id) {
3771
3850
  }
3772
3851
  return null;
3773
3852
  }
3774
- const raw = await fs5.promises.readFile(qmsFile, "utf-8");
3853
+ const raw = await fs6.promises.readFile(qmsFile, "utf-8");
3775
3854
  return JSON.parse(raw);
3776
3855
  }
3777
3856
  async function createGraphPackage(params) {
@@ -3779,8 +3858,8 @@ async function createGraphPackage(params) {
3779
3858
  const name = params.name.trim();
3780
3859
  const safeSlug = name.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-");
3781
3860
  const id = `${safeSlug}-${Date.now().toString(36)}`;
3782
- const graphDir = path5.join(GRAPHS_ROOT2, id);
3783
- await fs5.promises.mkdir(graphDir, { recursive: true });
3861
+ const graphDir = path6.join(GRAPHS_ROOT2, id);
3862
+ await fs6.promises.mkdir(graphDir, { recursive: true });
3784
3863
  await ensureGraphAssetDirectories(graphDir);
3785
3864
  seedStarterGraphAssets(graphDir);
3786
3865
  const now = Date.now();
@@ -3815,8 +3894,8 @@ async function createGraphPackage(params) {
3815
3894
  connections: params.connections || []
3816
3895
  }
3817
3896
  };
3818
- await fs5.promises.writeFile(
3819
- path5.join(graphDir, "graph.qms"),
3897
+ await fs6.promises.writeFile(
3898
+ path6.join(graphDir, "graph.qms"),
3820
3899
  JSON.stringify(graphPackage, null, 2),
3821
3900
  "utf-8"
3822
3901
  );
@@ -3824,10 +3903,10 @@ async function createGraphPackage(params) {
3824
3903
  }
3825
3904
  async function saveGraphPackage(id, payload) {
3826
3905
  ensureWorkspaceStructure();
3827
- const safeId = path5.basename(id);
3828
- const graphDir = path5.join(GRAPHS_ROOT2, safeId);
3829
- if (!fs5.existsSync(graphDir)) {
3830
- await fs5.promises.mkdir(graphDir, { recursive: true });
3906
+ const safeId = path6.basename(id);
3907
+ const graphDir = path6.join(GRAPHS_ROOT2, safeId);
3908
+ if (!fs6.existsSync(graphDir)) {
3909
+ await fs6.promises.mkdir(graphDir, { recursive: true });
3831
3910
  await ensureGraphAssetDirectories(graphDir);
3832
3911
  }
3833
3912
  const existing = await getGraphPackageById(safeId);
@@ -3862,18 +3941,18 @@ async function saveGraphPackage(id, payload) {
3862
3941
  mapIoConfig: payload.mapIoConfig || existing?.graph?.mapIoConfig
3863
3942
  }
3864
3943
  };
3865
- await fs5.promises.writeFile(
3866
- path5.join(graphDir, "graph.qms"),
3944
+ await fs6.promises.writeFile(
3945
+ path6.join(graphDir, "graph.qms"),
3867
3946
  JSON.stringify(graphPackage, null, 2),
3868
3947
  "utf-8"
3869
3948
  );
3870
3949
  return graphPackage;
3871
3950
  }
3872
3951
  async function deleteGraphPackage(id) {
3873
- const safeId = path5.basename(id);
3874
- const graphDir = path5.join(GRAPHS_ROOT2, safeId);
3875
- if (!fs5.existsSync(graphDir)) return false;
3876
- await fs5.promises.rm(graphDir, { recursive: true, force: true });
3952
+ const safeId = path6.basename(id);
3953
+ const graphDir = path6.join(GRAPHS_ROOT2, safeId);
3954
+ if (!fs6.existsSync(graphDir)) return false;
3955
+ await fs6.promises.rm(graphDir, { recursive: true, force: true });
3877
3956
  return true;
3878
3957
  }
3879
3958
  async function importGraphDependency(targetGraphId, candidateImportId) {
@@ -3915,26 +3994,26 @@ async function removeGraphDependency(targetGraphId, importIdToRemove) {
3915
3994
  }
3916
3995
 
3917
3996
  // src/server/services/projectService.ts
3918
- import fs6 from "fs";
3919
- import path6 from "path";
3920
- var PROJECTS_ROOT2 = path6.join(process.cwd(), "projects");
3997
+ import fs7 from "fs";
3998
+ import path7 from "path";
3999
+ var PROJECTS_ROOT2 = path7.join(process.cwd(), "projects");
3921
4000
  var customStarterProjectTemplate = null;
3922
4001
  function configureStarterProjectTemplate(template) {
3923
4002
  customStarterProjectTemplate = template;
3924
4003
  }
3925
4004
  function ensureProjectsRoot(starterTemplate) {
3926
- if (!fs6.existsSync(PROJECTS_ROOT2)) {
3927
- fs6.mkdirSync(PROJECTS_ROOT2, { recursive: true });
4005
+ if (!fs7.existsSync(PROJECTS_ROOT2)) {
4006
+ fs7.mkdirSync(PROJECTS_ROOT2, { recursive: true });
3928
4007
  }
3929
4008
  const template = starterTemplate || customStarterProjectTemplate;
3930
4009
  if (template && template.id) {
3931
- const defaultProjDir = path6.join(PROJECTS_ROOT2, String(template.id));
3932
- if (!fs6.existsSync(defaultProjDir)) {
3933
- fs6.mkdirSync(defaultProjDir, { recursive: true });
3934
- fs6.mkdirSync(path6.join(defaultProjDir, "samples"), { recursive: true });
3935
- fs6.mkdirSync(path6.join(defaultProjDir, "assets"), { recursive: true });
3936
- fs6.writeFileSync(
3937
- path6.join(defaultProjDir, "project.json"),
4010
+ const defaultProjDir = path7.join(PROJECTS_ROOT2, String(template.id));
4011
+ if (!fs7.existsSync(defaultProjDir)) {
4012
+ fs7.mkdirSync(defaultProjDir, { recursive: true });
4013
+ fs7.mkdirSync(path7.join(defaultProjDir, "samples"), { recursive: true });
4014
+ fs7.mkdirSync(path7.join(defaultProjDir, "assets"), { recursive: true });
4015
+ fs7.writeFileSync(
4016
+ path7.join(defaultProjDir, "project.json"),
3938
4017
  JSON.stringify({ ...template, createdAt: Date.now(), updatedAt: Date.now() }, null, 2),
3939
4018
  "utf-8"
3940
4019
  );
@@ -3943,22 +4022,22 @@ function ensureProjectsRoot(starterTemplate) {
3943
4022
  }
3944
4023
  async function listAllProjects() {
3945
4024
  ensureProjectsRoot();
3946
- const dirs = await fs6.promises.readdir(PROJECTS_ROOT2);
4025
+ const dirs = await fs7.promises.readdir(PROJECTS_ROOT2);
3947
4026
  const projects = [];
3948
4027
  for (const dir of dirs) {
3949
- const projDir = path6.join(PROJECTS_ROOT2, dir);
3950
- const stat = await fs6.promises.stat(projDir);
4028
+ const projDir = path7.join(PROJECTS_ROOT2, dir);
4029
+ const stat = await fs7.promises.stat(projDir);
3951
4030
  if (!stat.isDirectory()) continue;
3952
- const projectFile = path6.join(projDir, "project.json");
3953
- const samplesDir = path6.join(projDir, "samples");
4031
+ const projectFile = path7.join(projDir, "project.json");
4032
+ const samplesDir = path7.join(projDir, "samples");
3954
4033
  let sampleCount = 0;
3955
- if (fs6.existsSync(samplesDir)) {
3956
- const samples = await fs6.promises.readdir(samplesDir);
4034
+ if (fs7.existsSync(samplesDir)) {
4035
+ const samples = await fs7.promises.readdir(samplesDir);
3957
4036
  sampleCount = samples.filter((f) => !f.startsWith(".")).length;
3958
4037
  }
3959
- if (fs6.existsSync(projectFile)) {
4038
+ if (fs7.existsSync(projectFile)) {
3960
4039
  try {
3961
- const raw = await fs6.promises.readFile(projectFile, "utf-8");
4040
+ const raw = await fs7.promises.readFile(projectFile, "utf-8");
3962
4041
  const data = JSON.parse(raw);
3963
4042
  projects.push({
3964
4043
  id: data.id || dir,
@@ -3978,24 +4057,24 @@ async function listAllProjects() {
3978
4057
  return projects.sort((a, b) => b.updatedAt - a.updatedAt);
3979
4058
  }
3980
4059
  async function getProjectById(id) {
3981
- const safeId = path6.basename(id);
3982
- const projectFile = path6.join(PROJECTS_ROOT2, safeId, "project.json");
3983
- if (!fs6.existsSync(projectFile)) return null;
3984
- const raw = await fs6.promises.readFile(projectFile, "utf-8");
4060
+ const safeId = path7.basename(id);
4061
+ const projectFile = path7.join(PROJECTS_ROOT2, safeId, "project.json");
4062
+ if (!fs7.existsSync(projectFile)) return null;
4063
+ const raw = await fs7.promises.readFile(projectFile, "utf-8");
3985
4064
  return JSON.parse(raw);
3986
4065
  }
3987
4066
  async function saveProject(id, payload) {
3988
- const safeId = path6.basename(id);
3989
- const projDir = path6.join(PROJECTS_ROOT2, safeId);
3990
- const projectFile = path6.join(projDir, "project.json");
3991
- if (!fs6.existsSync(projDir)) {
3992
- await fs6.promises.mkdir(projDir, { recursive: true });
3993
- await fs6.promises.mkdir(path6.join(projDir, "samples"), { recursive: true });
3994
- await fs6.promises.mkdir(path6.join(projDir, "assets"), { recursive: true });
4067
+ const safeId = path7.basename(id);
4068
+ const projDir = path7.join(PROJECTS_ROOT2, safeId);
4069
+ const projectFile = path7.join(projDir, "project.json");
4070
+ if (!fs7.existsSync(projDir)) {
4071
+ await fs7.promises.mkdir(projDir, { recursive: true });
4072
+ await fs7.promises.mkdir(path7.join(projDir, "samples"), { recursive: true });
4073
+ await fs7.promises.mkdir(path7.join(projDir, "assets"), { recursive: true });
3995
4074
  }
3996
4075
  let existingData = {};
3997
- if (fs6.existsSync(projectFile)) {
3998
- const raw = await fs6.promises.readFile(projectFile, "utf-8");
4076
+ if (fs7.existsSync(projectFile)) {
4077
+ const raw = await fs7.promises.readFile(projectFile, "utf-8");
3999
4078
  existingData = JSON.parse(raw);
4000
4079
  }
4001
4080
  const updatedData = {
@@ -4004,22 +4083,22 @@ async function saveProject(id, payload) {
4004
4083
  id: safeId,
4005
4084
  updatedAt: Date.now()
4006
4085
  };
4007
- await fs6.promises.writeFile(projectFile, JSON.stringify(updatedData, null, 2), "utf-8");
4086
+ await fs7.promises.writeFile(projectFile, JSON.stringify(updatedData, null, 2), "utf-8");
4008
4087
  return updatedData;
4009
4088
  }
4010
4089
  async function deleteProject(id) {
4011
- const safeId = path6.basename(id);
4012
- const projDir = path6.join(PROJECTS_ROOT2, safeId);
4013
- if (!fs6.existsSync(projDir)) return false;
4014
- await fs6.promises.rm(projDir, { recursive: true, force: true });
4090
+ const safeId = path7.basename(id);
4091
+ const projDir = path7.join(PROJECTS_ROOT2, safeId);
4092
+ if (!fs7.existsSync(projDir)) return false;
4093
+ await fs7.promises.rm(projDir, { recursive: true, force: true });
4015
4094
  return true;
4016
4095
  }
4017
4096
 
4018
4097
  // src/server/services/sampleService.ts
4019
- import fs7 from "fs";
4020
- import path7 from "path";
4021
- var SAMPLES_GLOBAL_ROOT = path7.join(process.cwd(), "samples", "global");
4022
- var PROJECTS_ROOT3 = path7.join(process.cwd(), "projects");
4098
+ import fs8 from "fs";
4099
+ import path8 from "path";
4100
+ var SAMPLES_GLOBAL_ROOT = path8.join(process.cwd(), "samples", "global");
4101
+ var PROJECTS_ROOT3 = path8.join(process.cwd(), "projects");
4023
4102
  var SUPPORTED_AUDIO_EXTS3 = [".wav", ".mp3", ".ogg", ".flac", ".m4a", ".webm", ".weba", ".aac", ".aiff", ".aif", ".opus", ".mp4"];
4024
4103
  function initGlobalSamplesDirectory() {
4025
4104
  ensureGlobalSamples(SAMPLES_GLOBAL_ROOT).catch((err) => {
@@ -4027,17 +4106,17 @@ function initGlobalSamplesDirectory() {
4027
4106
  });
4028
4107
  }
4029
4108
  async function listGlobalSamples() {
4030
- if (!fs7.existsSync(SAMPLES_GLOBAL_ROOT)) {
4031
- await fs7.promises.mkdir(SAMPLES_GLOBAL_ROOT, { recursive: true });
4109
+ if (!fs8.existsSync(SAMPLES_GLOBAL_ROOT)) {
4110
+ await fs8.promises.mkdir(SAMPLES_GLOBAL_ROOT, { recursive: true });
4032
4111
  }
4033
- const files = await fs7.promises.readdir(SAMPLES_GLOBAL_ROOT);
4112
+ const files = await fs8.promises.readdir(SAMPLES_GLOBAL_ROOT);
4034
4113
  const samples = [];
4035
4114
  for (const file of files) {
4036
- const ext = path7.extname(file).toLowerCase();
4115
+ const ext = path8.extname(file).toLowerCase();
4037
4116
  if (!SUPPORTED_AUDIO_EXTS3.includes(ext)) continue;
4038
- const filePath = path7.join(SAMPLES_GLOBAL_ROOT, file);
4039
- const stat = await fs7.promises.stat(filePath);
4040
- const baseName = path7.basename(file, ext);
4117
+ const filePath = path8.join(SAMPLES_GLOBAL_ROOT, file);
4118
+ const stat = await fs8.promises.stat(filePath);
4119
+ const baseName = path8.basename(file, ext);
4041
4120
  const cleanName = baseName.replace(/[-_]/g, " ");
4042
4121
  let category = "synth";
4043
4122
  if (/808|kick|snare|hihat|drum|perc/i.test(baseName)) category = "drums";
@@ -4057,15 +4136,15 @@ async function listGlobalSamples() {
4057
4136
  return samples;
4058
4137
  }
4059
4138
  async function saveGlobalSample(filename, base64Content, category) {
4060
- const safeFilename = path7.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_");
4061
- const ext = path7.extname(safeFilename).toLowerCase() || ".wav";
4062
- const filePath = path7.join(SAMPLES_GLOBAL_ROOT, safeFilename);
4139
+ const safeFilename = path8.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_");
4140
+ const ext = path8.extname(safeFilename).toLowerCase() || ".wav";
4141
+ const filePath = path8.join(SAMPLES_GLOBAL_ROOT, safeFilename);
4063
4142
  const buffer = Buffer.from(base64Content, "base64");
4064
- await fs7.promises.writeFile(filePath, buffer);
4065
- const stat = await fs7.promises.stat(filePath);
4143
+ await fs8.promises.writeFile(filePath, buffer);
4144
+ const stat = await fs8.promises.stat(filePath);
4066
4145
  return {
4067
4146
  filename: safeFilename,
4068
- name: path7.basename(safeFilename, ext).replace(/[-_]/g, " "),
4147
+ name: path8.basename(safeFilename, ext).replace(/[-_]/g, " "),
4069
4148
  category: category || "custom",
4070
4149
  format: ext.replace(".", "").toUpperCase(),
4071
4150
  url: `/samples/global/${safeFilename}`,
@@ -4075,28 +4154,28 @@ async function saveGlobalSample(filename, base64Content, category) {
4075
4154
  };
4076
4155
  }
4077
4156
  async function deleteGlobalSample(filename) {
4078
- const safeFilename = path7.basename(filename);
4079
- const filePath = path7.join(SAMPLES_GLOBAL_ROOT, safeFilename);
4080
- if (fs7.existsSync(filePath)) {
4081
- await fs7.promises.unlink(filePath);
4157
+ const safeFilename = path8.basename(filename);
4158
+ const filePath = path8.join(SAMPLES_GLOBAL_ROOT, safeFilename);
4159
+ if (fs8.existsSync(filePath)) {
4160
+ await fs8.promises.unlink(filePath);
4082
4161
  return true;
4083
4162
  }
4084
4163
  return false;
4085
4164
  }
4086
4165
  async function listProjectSamples(projectId) {
4087
- const safeId = path7.basename(projectId);
4088
- const samplesDir = path7.join(PROJECTS_ROOT3, safeId, "samples");
4089
- if (!fs7.existsSync(samplesDir)) {
4090
- await fs7.promises.mkdir(samplesDir, { recursive: true });
4166
+ const safeId = path8.basename(projectId);
4167
+ const samplesDir = path8.join(PROJECTS_ROOT3, safeId, "samples");
4168
+ if (!fs8.existsSync(samplesDir)) {
4169
+ await fs8.promises.mkdir(samplesDir, { recursive: true });
4091
4170
  }
4092
- const files = await fs7.promises.readdir(samplesDir);
4171
+ const files = await fs8.promises.readdir(samplesDir);
4093
4172
  const samples = [];
4094
4173
  for (const file of files) {
4095
- const ext = path7.extname(file).toLowerCase();
4174
+ const ext = path8.extname(file).toLowerCase();
4096
4175
  if (!SUPPORTED_AUDIO_EXTS3.includes(ext)) continue;
4097
- const filePath = path7.join(samplesDir, file);
4098
- const stat = await fs7.promises.stat(filePath);
4099
- const baseName = path7.basename(file, ext);
4176
+ const filePath = path8.join(samplesDir, file);
4177
+ const stat = await fs8.promises.stat(filePath);
4178
+ const baseName = path8.basename(file, ext);
4100
4179
  samples.push({
4101
4180
  filename: file,
4102
4181
  name: baseName.replace(/[-_]/g, " "),
@@ -4112,21 +4191,21 @@ async function listProjectSamples(projectId) {
4112
4191
  return samples;
4113
4192
  }
4114
4193
  async function saveProjectSample(projectId, filename, base64Content, isRecording) {
4115
- const safeId = path7.basename(projectId);
4116
- const samplesDir = path7.join(PROJECTS_ROOT3, safeId, "samples");
4117
- if (!fs7.existsSync(samplesDir)) {
4118
- await fs7.promises.mkdir(samplesDir, { recursive: true });
4194
+ const safeId = path8.basename(projectId);
4195
+ const samplesDir = path8.join(PROJECTS_ROOT3, safeId, "samples");
4196
+ if (!fs8.existsSync(samplesDir)) {
4197
+ await fs8.promises.mkdir(samplesDir, { recursive: true });
4119
4198
  }
4120
4199
  const defaultName = isRecording ? `recording_take_${Date.now()}.wav` : `clip_${Date.now()}.wav`;
4121
- const targetFilename = filename ? path7.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_") : defaultName;
4122
- const ext = path7.extname(targetFilename).toLowerCase() || ".wav";
4123
- const filePath = path7.join(samplesDir, targetFilename);
4200
+ const targetFilename = filename ? path8.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_") : defaultName;
4201
+ const ext = path8.extname(targetFilename).toLowerCase() || ".wav";
4202
+ const filePath = path8.join(samplesDir, targetFilename);
4124
4203
  const buffer = Buffer.from(base64Content, "base64");
4125
- await fs7.promises.writeFile(filePath, buffer);
4126
- const stat = await fs7.promises.stat(filePath);
4204
+ await fs8.promises.writeFile(filePath, buffer);
4205
+ const stat = await fs8.promises.stat(filePath);
4127
4206
  return {
4128
4207
  filename: targetFilename,
4129
- name: path7.basename(targetFilename, ext).replace(/[-_]/g, " "),
4208
+ name: path8.basename(targetFilename, ext).replace(/[-_]/g, " "),
4130
4209
  category: isRecording ? "recording" : "import",
4131
4210
  format: ext.replace(".", "").toUpperCase(),
4132
4211
  url: `/projects/${safeId}/samples/${targetFilename}`,
@@ -4137,26 +4216,26 @@ async function saveProjectSample(projectId, filename, base64Content, isRecording
4137
4216
  };
4138
4217
  }
4139
4218
  async function deleteProjectSample(projectId, filename) {
4140
- const safeId = path7.basename(projectId);
4141
- const safeFilename = path7.basename(filename);
4142
- const filePath = path7.join(PROJECTS_ROOT3, safeId, "samples", safeFilename);
4143
- if (fs7.existsSync(filePath)) {
4144
- await fs7.promises.unlink(filePath);
4219
+ const safeId = path8.basename(projectId);
4220
+ const safeFilename = path8.basename(filename);
4221
+ const filePath = path8.join(PROJECTS_ROOT3, safeId, "samples", safeFilename);
4222
+ if (fs8.existsSync(filePath)) {
4223
+ await fs8.promises.unlink(filePath);
4145
4224
  return true;
4146
4225
  }
4147
4226
  return false;
4148
4227
  }
4149
4228
 
4150
4229
  // src/server/services/workspaceGraphService.ts
4151
- import fs8 from "fs";
4152
- import path8 from "path";
4153
- var AUTH_FILE_PATH = path8.resolve(".skipo/accounts.json");
4230
+ import fs9 from "fs";
4231
+ import path9 from "path";
4232
+ var AUTH_FILE_PATH = path9.resolve(".skipo/accounts.json");
4154
4233
  async function resolveWorkspaceDir(workspaceIdOrSlug) {
4155
4234
  const workingDir = getWorkingWorkspaceDir();
4156
4235
  let targetWs = null;
4157
4236
  try {
4158
- if (fs8.existsSync(AUTH_FILE_PATH)) {
4159
- const raw = await fs8.promises.readFile(AUTH_FILE_PATH, "utf-8");
4237
+ if (fs9.existsSync(AUTH_FILE_PATH)) {
4238
+ const raw = await fs9.promises.readFile(AUTH_FILE_PATH, "utf-8");
4160
4239
  const accounts = JSON.parse(raw);
4161
4240
  for (const user of Object.values(accounts)) {
4162
4241
  if (Array.isArray(user.workspaces)) {
@@ -4176,35 +4255,35 @@ async function resolveWorkspaceDir(workspaceIdOrSlug) {
4176
4255
  if (targetWs) {
4177
4256
  const rawFolderName = targetWs.localFolderName || targetWs.name.replace(/[/\\?%*:|"<>]/g, "_");
4178
4257
  const folderName = rawFolderName.trim();
4179
- await fs8.promises.mkdir(workingDir, { recursive: true });
4258
+ await fs9.promises.mkdir(workingDir, { recursive: true });
4180
4259
  return { wsDir: workingDir, wsName: targetWs.name, wsFolder: folderName, wsId: targetWs.id };
4181
4260
  }
4182
- await fs8.promises.mkdir(workingDir, { recursive: true });
4261
+ await fs9.promises.mkdir(workingDir, { recursive: true });
4183
4262
  return { wsDir: workingDir, wsName: "Active Workspace", wsFolder: "workspace", wsId: workspaceIdOrSlug || "default" };
4184
4263
  }
4185
4264
  async function listWorkspaceGraphs(workspaceIdOrSlug) {
4186
4265
  const { wsDir, wsFolder } = await resolveWorkspaceDir(workspaceIdOrSlug);
4187
4266
  const graphs = [];
4188
4267
  const inspectDirForGraph = async (dirPath, folderName) => {
4189
- const projectJson = path8.join(dirPath, "project.json");
4190
- const graphQms = path8.join(dirPath, "graph.qms");
4268
+ const projectJson = path9.join(dirPath, "project.json");
4269
+ const graphQms = path9.join(dirPath, "graph.qms");
4191
4270
  let data = null;
4192
- if (fs8.existsSync(projectJson)) {
4271
+ if (fs9.existsSync(projectJson)) {
4193
4272
  try {
4194
- const raw = await fs8.promises.readFile(projectJson, "utf-8");
4273
+ const raw = await fs9.promises.readFile(projectJson, "utf-8");
4195
4274
  data = JSON.parse(raw);
4196
4275
  } catch {
4197
4276
  }
4198
- } else if (fs8.existsSync(graphQms)) {
4277
+ } else if (fs9.existsSync(graphQms)) {
4199
4278
  try {
4200
- const raw = await fs8.promises.readFile(graphQms, "utf-8");
4279
+ const raw = await fs9.promises.readFile(graphQms, "utf-8");
4201
4280
  const pkg = JSON.parse(raw);
4202
4281
  data = { ...pkg.metadata || {}, ...pkg.graph || {} };
4203
4282
  } catch {
4204
4283
  }
4205
4284
  }
4206
4285
  if (!data) return null;
4207
- const stat = await fs8.promises.stat(dirPath);
4286
+ const stat = await fs9.promises.stat(dirPath);
4208
4287
  const nodeCount = Array.isArray(data.nodes) ? data.nodes.length : 0;
4209
4288
  const connectionCount = Array.isArray(data.connections) ? data.connections.length : 0;
4210
4289
  return {
@@ -4212,7 +4291,7 @@ async function listWorkspaceGraphs(workspaceIdOrSlug) {
4212
4291
  name: data.name || folderName,
4213
4292
  description: data.description || "",
4214
4293
  folderName,
4215
- folderPath: path8.relative(process.cwd(), dirPath).replace(/\\/g, "/"),
4294
+ folderPath: path9.relative(process.cwd(), dirPath).replace(/\\/g, "/"),
4216
4295
  createdAt: data.createdAt || stat.birthtimeMs,
4217
4296
  updatedAt: data.updatedAt || stat.mtimeMs,
4218
4297
  bpm: data.bpm || 120,
@@ -4225,18 +4304,18 @@ async function listWorkspaceGraphs(workspaceIdOrSlug) {
4225
4304
  connectionCount
4226
4305
  };
4227
4306
  };
4228
- const entries = await fs8.promises.readdir(wsDir);
4307
+ const entries = await fs9.promises.readdir(wsDir);
4229
4308
  for (const entry of entries) {
4230
4309
  if (entry.startsWith(".") || entry === "samples" || entry === "assets") continue;
4231
- const fullPath = path8.join(wsDir, entry);
4232
- const stat = await fs8.promises.stat(fullPath);
4310
+ const fullPath = path9.join(wsDir, entry);
4311
+ const stat = await fs9.promises.stat(fullPath);
4233
4312
  if (!stat.isDirectory()) continue;
4234
4313
  if (entry === "graphs") {
4235
- const subEntries = await fs8.promises.readdir(fullPath);
4314
+ const subEntries = await fs9.promises.readdir(fullPath);
4236
4315
  for (const sub of subEntries) {
4237
4316
  if (sub.startsWith(".")) continue;
4238
- const subPath = path8.join(fullPath, sub);
4239
- const subStat = await fs8.promises.stat(subPath);
4317
+ const subPath = path9.join(fullPath, sub);
4318
+ const subStat = await fs9.promises.stat(subPath);
4240
4319
  if (subStat.isDirectory()) {
4241
4320
  const g2 = await inspectDirForGraph(subPath, sub);
4242
4321
  if (g2) graphs.push(g2);
@@ -4253,10 +4332,10 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
4253
4332
  const { wsDir, wsFolder, wsId } = await resolveWorkspaceDir(workspaceIdOrSlug);
4254
4333
  const rawName = params.name.trim();
4255
4334
  const folderName = rawName.replace(/[/\\?%*:|"<>]/g, "_");
4256
- const graphDir = path8.join(wsDir, folderName);
4257
- await fs8.promises.mkdir(graphDir, { recursive: true });
4258
- await fs8.promises.mkdir(path8.join(graphDir, "samples"), { recursive: true });
4259
- await fs8.promises.mkdir(path8.join(graphDir, "assets"), { recursive: true });
4335
+ const graphDir = path9.join(wsDir, folderName);
4336
+ await fs9.promises.mkdir(graphDir, { recursive: true });
4337
+ await fs9.promises.mkdir(path9.join(graphDir, "samples"), { recursive: true });
4338
+ await fs9.promises.mkdir(path9.join(graphDir, "assets"), { recursive: true });
4260
4339
  const now = Date.now();
4261
4340
  const nodes = params.templateData?.nodes || [];
4262
4341
  const connections = params.templateData?.connections || [];
@@ -4267,7 +4346,7 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
4267
4346
  id: folderName,
4268
4347
  name: rawName,
4269
4348
  description: params.description || `Workspace graph in ${wsFolder}`,
4270
- folderPath: path8.relative(process.cwd(), graphDir).replace(/\\/g, "/"),
4349
+ folderPath: path9.relative(process.cwd(), graphDir).replace(/\\/g, "/"),
4271
4350
  createdAt: now,
4272
4351
  updatedAt: now,
4273
4352
  bpm,
@@ -4276,7 +4355,7 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
4276
4355
  nodes,
4277
4356
  connections
4278
4357
  };
4279
- await fs8.promises.writeFile(path8.join(graphDir, "project.json"), JSON.stringify(projectData, null, 2), "utf-8");
4358
+ await fs9.promises.writeFile(path9.join(graphDir, "project.json"), JSON.stringify(projectData, null, 2), "utf-8");
4280
4359
  const graphPackage = {
4281
4360
  format: "qms_graph_package",
4282
4361
  version: "2.0.0",
@@ -4294,27 +4373,27 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
4294
4373
  },
4295
4374
  graph: { bpm, masterVolume, currentBiome, nodes, connections }
4296
4375
  };
4297
- await fs8.promises.writeFile(path8.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
4376
+ await fs9.promises.writeFile(path9.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
4298
4377
  return projectData;
4299
4378
  }
4300
4379
  async function getWorkspaceGraph(workspaceIdOrSlug, graphIdOrName) {
4301
4380
  const { wsDir } = await resolveWorkspaceDir(workspaceIdOrSlug);
4302
4381
  const safeTarget = graphIdOrName.replace(/[/\\?%*:|"<>]/g, "_");
4303
4382
  const candidates = [
4304
- path8.join(wsDir, safeTarget),
4305
- path8.join(wsDir, graphIdOrName),
4306
- path8.join(wsDir, "graphs", safeTarget)
4383
+ path9.join(wsDir, safeTarget),
4384
+ path9.join(wsDir, graphIdOrName),
4385
+ path9.join(wsDir, "graphs", safeTarget)
4307
4386
  ];
4308
4387
  for (const cand of candidates) {
4309
- if (fs8.existsSync(cand)) {
4310
- const pJson = path8.join(cand, "project.json");
4311
- if (fs8.existsSync(pJson)) {
4312
- const raw = await fs8.promises.readFile(pJson, "utf-8");
4388
+ if (fs9.existsSync(cand)) {
4389
+ const pJson = path9.join(cand, "project.json");
4390
+ if (fs9.existsSync(pJson)) {
4391
+ const raw = await fs9.promises.readFile(pJson, "utf-8");
4313
4392
  return JSON.parse(raw);
4314
4393
  }
4315
- const gQms = path8.join(cand, "graph.qms");
4316
- if (fs8.existsSync(gQms)) {
4317
- const raw = await fs8.promises.readFile(gQms, "utf-8");
4394
+ const gQms = path9.join(cand, "graph.qms");
4395
+ if (fs9.existsSync(gQms)) {
4396
+ const raw = await fs9.promises.readFile(gQms, "utf-8");
4318
4397
  const pkg = JSON.parse(raw);
4319
4398
  return { ...pkg.metadata || {}, ...pkg.graph || {} };
4320
4399
  }
@@ -4325,50 +4404,114 @@ async function getWorkspaceGraph(workspaceIdOrSlug, graphIdOrName) {
4325
4404
  async function saveWorkspaceGraph(workspaceIdOrSlug, graphIdOrName, payload) {
4326
4405
  const { wsDir } = await resolveWorkspaceDir(workspaceIdOrSlug);
4327
4406
  const safeTarget = graphIdOrName.replace(/[/\\?%*:|"<>]/g, "_");
4328
- let targetDir = path8.join(wsDir, safeTarget);
4329
- if (!fs8.existsSync(targetDir) && fs8.existsSync(path8.join(wsDir, "graphs", safeTarget))) {
4330
- targetDir = path8.join(wsDir, "graphs", safeTarget);
4407
+ let targetDir = path9.join(wsDir, safeTarget);
4408
+ if (!fs9.existsSync(targetDir) && fs9.existsSync(path9.join(wsDir, "graphs", safeTarget))) {
4409
+ targetDir = path9.join(wsDir, "graphs", safeTarget);
4331
4410
  }
4332
- await fs8.promises.mkdir(targetDir, { recursive: true });
4333
- const pJson = path8.join(targetDir, "project.json");
4411
+ await fs9.promises.mkdir(targetDir, { recursive: true });
4412
+ const pJson = path9.join(targetDir, "project.json");
4334
4413
  let existing = {};
4335
- if (fs8.existsSync(pJson)) {
4414
+ if (fs9.existsSync(pJson)) {
4336
4415
  try {
4337
- existing = JSON.parse(await fs8.promises.readFile(pJson, "utf-8"));
4416
+ existing = JSON.parse(await fs9.promises.readFile(pJson, "utf-8"));
4338
4417
  } catch {
4339
4418
  }
4340
4419
  }
4341
4420
  const updated = {
4342
4421
  ...existing,
4343
4422
  ...payload,
4344
- id: existing.id || path8.basename(targetDir),
4423
+ id: existing.id || path9.basename(targetDir),
4345
4424
  updatedAt: Date.now()
4346
4425
  };
4347
- await fs8.promises.writeFile(pJson, JSON.stringify(updated, null, 2), "utf-8");
4426
+ await fs9.promises.writeFile(pJson, JSON.stringify(updated, null, 2), "utf-8");
4348
4427
  return updated;
4349
4428
  }
4350
4429
  async function deleteWorkspaceGraph(workspaceIdOrSlug, graphIdOrName) {
4351
4430
  const { wsDir } = await resolveWorkspaceDir(workspaceIdOrSlug);
4352
4431
  const safeTarget = graphIdOrName.replace(/[/\\?%*:|"<>]/g, "_");
4353
4432
  const candidates = [
4354
- path8.join(wsDir, safeTarget),
4355
- path8.join(wsDir, graphIdOrName),
4356
- path8.join(wsDir, "graphs", safeTarget)
4433
+ path9.join(wsDir, safeTarget),
4434
+ path9.join(wsDir, graphIdOrName),
4435
+ path9.join(wsDir, "graphs", safeTarget)
4357
4436
  ];
4358
4437
  for (const cand of candidates) {
4359
- if (fs8.existsSync(cand)) {
4360
- await fs8.promises.rm(cand, { recursive: true, force: true });
4438
+ if (fs9.existsSync(cand)) {
4439
+ await fs9.promises.rm(cand, { recursive: true, force: true });
4361
4440
  return true;
4362
4441
  }
4363
4442
  }
4364
4443
  return false;
4365
4444
  }
4366
4445
 
4367
- // src/development/wasmRuntimeService.ts
4446
+ // src/krnl-services.node.ts
4368
4447
  import {
4369
4448
  createService,
4370
4449
  createServiceDefinition
4371
4450
  } from "@ultrst-armada/krnl";
4451
+ var WorkspaceGraphServiceDefinition = createServiceDefinition({
4452
+ id: "kloks.backend.workspaceGraph",
4453
+ name: "WorkspaceGraphService",
4454
+ version: "1.0.0",
4455
+ operations: {
4456
+ listGraphs: {
4457
+ id: "WorkspaceGraphService.listGraphs",
4458
+ name: "listGraphs",
4459
+ handler: async (input) => workspaceGraphService.listGraphs(input.userId, input.workspaceId)
4460
+ },
4461
+ createGraph: {
4462
+ id: "WorkspaceGraphService.createGraph",
4463
+ name: "createGraph",
4464
+ handler: async (input) => workspaceGraphService.createGraph(input.userId, input.workspaceId, { name: input.name })
4465
+ },
4466
+ getGraph: {
4467
+ id: "WorkspaceGraphService.getGraph",
4468
+ name: "getGraph",
4469
+ handler: async (input) => workspaceGraphService.getGraph(input.userId, input.workspaceId, input.slug)
4470
+ },
4471
+ saveGraph: {
4472
+ id: "WorkspaceGraphService.saveGraph",
4473
+ name: "saveGraph",
4474
+ handler: async (input) => workspaceGraphService.saveGraph(input.userId, input.workspaceId, input.slug, input)
4475
+ },
4476
+ deleteGraph: {
4477
+ id: "WorkspaceGraphService.deleteGraph",
4478
+ name: "deleteGraph",
4479
+ handler: async (input) => workspaceGraphService.deleteGraph(input.userId, input.workspaceId, input.slug)
4480
+ },
4481
+ duplicateGraph: {
4482
+ id: "WorkspaceGraphService.duplicateGraph",
4483
+ name: "duplicateGraph",
4484
+ handler: async (input) => workspaceGraphService.duplicateGraph(input.userId, input.workspaceId, input.slug, input.newName)
4485
+ },
4486
+ clearGraph: {
4487
+ id: "WorkspaceGraphService.clearGraph",
4488
+ name: "clearGraph",
4489
+ handler: async (input) => workspaceGraphService.clearGraph(input.userId, input.workspaceId, input.slug)
4490
+ }
4491
+ }
4492
+ });
4493
+ var workspaceGraphServiceInstance = createService(WorkspaceGraphServiceDefinition);
4494
+ var WorkspaceGraphServiceFacade = {
4495
+ id: WorkspaceGraphServiceDefinition.id,
4496
+ name: WorkspaceGraphServiceDefinition.name,
4497
+ version: WorkspaceGraphServiceDefinition.version,
4498
+ runtime: "server",
4499
+ deployment: "local",
4500
+ definition: WorkspaceGraphServiceDefinition,
4501
+ createInstance: () => createService(WorkspaceGraphServiceDefinition),
4502
+ execute: async (op, input) => {
4503
+ await workspaceGraphServiceInstance.start();
4504
+ return workspaceGraphServiceInstance.call(op, input);
4505
+ }
4506
+ };
4507
+ var krnlWorkspaceGraphServiceDefinition = WorkspaceGraphServiceDefinition;
4508
+ var krnlWorkspaceGraphServiceFacade = WorkspaceGraphServiceFacade;
4509
+
4510
+ // src/development/wasmRuntimeService.ts
4511
+ import {
4512
+ createService as createService2,
4513
+ createServiceDefinition as createServiceDefinition2
4514
+ } from "@ultrst-armada/krnl";
4372
4515
  var runtime;
4373
4516
  async function getRuntime(options = {}) {
4374
4517
  if (!runtime) {
@@ -4377,7 +4520,7 @@ async function getRuntime(options = {}) {
4377
4520
  }
4378
4521
  return runtime;
4379
4522
  }
4380
- var WasmRuntimeServiceDefinition = createServiceDefinition({
4523
+ var WasmRuntimeServiceDefinition = createServiceDefinition2({
4381
4524
  id: "kloks.backend.wasmRuntime",
4382
4525
  name: "WasmRuntimeService",
4383
4526
  version: "1.0.0",
@@ -4405,9 +4548,9 @@ var WasmRuntimeServiceFacade = {
4405
4548
  name: WasmRuntimeServiceDefinition.name,
4406
4549
  version: WasmRuntimeServiceDefinition.version,
4407
4550
  definition: WasmRuntimeServiceDefinition,
4408
- createInstance: () => createService(WasmRuntimeServiceDefinition),
4551
+ createInstance: () => createService2(WasmRuntimeServiceDefinition),
4409
4552
  execute: async (operation, input) => {
4410
- const instance = createService(WasmRuntimeServiceDefinition);
4553
+ const instance = createService2(WasmRuntimeServiceDefinition);
4411
4554
  await instance.start();
4412
4555
  return instance.call(operation, input);
4413
4556
  }
@@ -4535,16 +4678,23 @@ export {
4535
4678
  classifyAndFormatError,
4536
4679
  cleanDbUrl,
4537
4680
  clearLuthDiscoveryCache,
4681
+ completeGoogleDriveAuthorization,
4682
+ completeGoogleDriveAuthorizationCallback,
4538
4683
  computeDeploymentFinalWeight,
4539
4684
  computeUsageWeightScore,
4685
+ configureLocalWorkspaceFileAdapter,
4540
4686
  configureStarterProjectTemplate,
4687
+ configureUnifiedDatabaseEnvironmentResolver,
4541
4688
  createAssetSubfolder,
4689
+ createBackblazeStorageConnection,
4542
4690
  createBackend,
4543
4691
  createBackendClient,
4544
4692
  createLuthAuthClient2 as createCanonicalAuthClient,
4545
4693
  createCompositeService,
4546
4694
  createCredential,
4547
4695
  createEmptyContract,
4696
+ createGoogleDriveAuthorizationRequest,
4697
+ createGoogleDriveWorkspaceClient,
4548
4698
  createGraphAssetFolder,
4549
4699
  createGraphAssetFolder as createGraphAssetSubfolder,
4550
4700
  createGraphPackage,
@@ -4562,10 +4712,14 @@ export {
4562
4712
  deleteAssetFromPool,
4563
4713
  deleteCredential,
4564
4714
  deleteGlobalSample,
4715
+ deleteGoogleDriveFileForConnection,
4565
4716
  deleteGraphPackage,
4566
4717
  deleteProject,
4567
4718
  deleteProjectSample,
4568
4719
  deleteRoute,
4720
+ deleteUserStorageConnection,
4721
+ deleteUserWorkspaceStorageFile,
4722
+ deleteUserWorkspaceStorageFolder,
4569
4723
  deleteWorkspace,
4570
4724
  deleteWorkspaceFile,
4571
4725
  deleteWorkspaceFolder,
@@ -4600,6 +4754,7 @@ export {
4600
4754
  getDefaultWorkingWorkspaceDir,
4601
4755
  getExecutions,
4602
4756
  getGatewayConfig,
4757
+ getGoogleDriveAccountIdentityForUser,
4603
4758
  getGraphPackageById,
4604
4759
  getNextLuthDeploymentUrl,
4605
4760
  getPrimaryLuthDeploymentUrl,
@@ -4613,7 +4768,9 @@ export {
4613
4768
  getSrklAccounts,
4614
4769
  getSrklAccounts2 as getSrklCoreAccounts,
4615
4770
  getSrklStatus,
4771
+ getStorageProviderCapabilities,
4616
4772
  getSystemDatabaseUrls,
4773
+ getSystemGoogleOAuthConfiguration,
4617
4774
  getUnifiedDbUrl,
4618
4775
  getWeightModifierScore,
4619
4776
  getWorkingWorkspaceConfig,
@@ -4631,6 +4788,7 @@ export {
4631
4788
  inferenceExecutor,
4632
4789
  initGlobalSamplesDirectory,
4633
4790
  isB2Workspace,
4791
+ isGoogleDriveWorkspace,
4634
4792
  isSecretMasked,
4635
4793
  keyStore,
4636
4794
  keysStorage,
@@ -4653,10 +4811,16 @@ export {
4653
4811
  listAllGraphPackages,
4654
4812
  listAllProjects,
4655
4813
  listBackblazeBuckets,
4814
+ listBackblazeBucketsForConnection,
4656
4815
  listCredentials,
4657
4816
  listGlobalSamples,
4817
+ listGoogleDriveFilesForConnection,
4818
+ listGoogleDriveFoldersForConnection,
4658
4819
  listProjectSamples,
4659
4820
  listProviders,
4821
+ listUserStorageConnections,
4822
+ listUserStorageConnectionsWithSecrets,
4823
+ listUserWorkspaceStorageFiles,
4660
4824
  listWorkspaceFiles,
4661
4825
  listWorkspaceGraphs,
4662
4826
  loadCredentialManifest,
@@ -4670,6 +4834,8 @@ export {
4670
4834
  modelHealthService,
4671
4835
  nodeGraphPersistence,
4672
4836
  normalizeBackblazeCredentials,
4837
+ normalizeSystemEnvironment,
4838
+ normalizeWorkspaceStoragePath,
4673
4839
  parseErrorJson,
4674
4840
  parseGraphJsonFile,
4675
4841
  pauseCloudflarePagesProject,
@@ -4677,7 +4843,10 @@ export {
4677
4843
  performInference,
4678
4844
  permanentDeleteS3Folder,
4679
4845
  permanentDeleteS3Object,
4846
+ persistGoogleDriveTokens,
4680
4847
  queryUnifiedDb,
4848
+ readGoogleDriveFileForConnection,
4849
+ readUserWorkspaceStorageFile,
4681
4850
  readWorkspaceFile,
4682
4851
  recordExecution,
4683
4852
  remoteWorkspaceService,
@@ -4690,7 +4859,10 @@ export {
4690
4859
  resolveDynamicRouteFromDb,
4691
4860
  resolveSystemDatabaseClusterNodes,
4692
4861
  resolveSystemDatabaseUrl,
4862
+ resolveSystemDatabaseUrlCandidates,
4693
4863
  resolveUserFromToken,
4864
+ resolveUserStorageConnectionSecret,
4865
+ resolveUserWorkspaceStorageAssociation,
4694
4866
  resolveWorkspaceConnection,
4695
4867
  resolveWorkspaceDir,
4696
4868
  resumeCloudflarePagesProject,
@@ -4709,7 +4881,9 @@ export {
4709
4881
  scanGraphAssets,
4710
4882
  seedDefaultAssets,
4711
4883
  seedStarterGraphAssets,
4884
+ selectGoogleDriveRootFolder,
4712
4885
  serverPublicRoutes,
4886
+ setPrimaryUserStorageConnection,
4713
4887
  setServerPublicRoutes,
4714
4888
  setWorkingWorkspaceConfig,
4715
4889
  srklListBackblazeBuckets2 as srklCoreListBackblazeBuckets,
@@ -4720,6 +4894,9 @@ export {
4720
4894
  syncWorkspaceCreateToBucket,
4721
4895
  syncWorkspaceDataToBucket,
4722
4896
  syncWorkspaceDeleteToBucket,
4897
+ testBackblazeCredentials,
4898
+ testGoogleDriveConnectionForUser,
4899
+ toPublicStorageConnection,
4723
4900
  toolManagerService,
4724
4901
  tryResolveSystemDatabaseUrl,
4725
4902
  updateCredential,
@@ -4732,9 +4909,12 @@ export {
4732
4909
  validateGraphDocument,
4733
4910
  validateServiceDefinition,
4734
4911
  validateToolInput,
4912
+ verifyGoogleDriveAuthorizationState,
4735
4913
  withAuth,
4736
4914
  withCors,
4737
4915
  workingWorkspaceService,
4738
4916
  workspaceGraphService,
4917
+ writeGoogleDriveFileForConnection,
4918
+ writeUserWorkspaceStorageFile,
4739
4919
  writeWorkspaceFile
4740
4920
  };