Fix storage plugin initialization for multi-project artifact publishing

Author: hotlong

apps/cloud/wrangler.toml

@@ -45,7 +45,7 @@ compatibility_flags = ["nodejs_compat"]
 # rebuild + re-push to ship a new version, then run `wrangler deploy`.
 [[containers]]
 class_name = "CloudContainer"
-image = "registry.cloudflare.com/2846eb40a60f4738e292b90dcd8cce10/objectstack-cloud:publish-diag"
+image = "registry.cloudflare.com/2846eb40a60f4738e292b90dcd8cce10/objectstack-cloud:direct-storage"
 max_instances = 3
 instance_type = "standard-1"
 

packages/services/service-cloud/src/cloud-stack.ts

@@ -21,7 +21,7 @@ import { createControlPlanePlugins } from './control-plane-preset.js';
 import { createStudioRuntimeConfigPlugin, createTemplatesRoutePlugin } from './multi-project-plugins.js';
 import { createCloudArtifactApiPlugin } from './cloud-artifact-api-plugin.js';
 import { resolveDefaultDataDir } from './data-dir.js';
-import { resolveStoragePluginFromEnv } from './storage-env.js';
+import { resolveStoragePluginFromEnv, resolveStorageFromEnv } from './storage-env.js';
 
 type IDataDriver = Contracts.IDataDriver;
 
@@ -161,6 +161,12 @@ export async function createCloudStack(config: CloudStackConfig): Promise<{
         ];
     });
 
+    // Resolve storage ONCE so we can wire both StorageServicePlugin (kernel
+    // service registration + REST routes) AND pass the raw adapter directly to
+    // MultiProjectPlugin (avoids cross-plugin kernel.getService lookup which
+    // is unreliable through the proxy wrapper used here).
+    const storageEnv = await resolveStorageFromEnv();
+
     const multiProjectPluginProxy: any = {
         name: 'com.objectstack.multi-project',
         version: '0.0.0',
@@ -176,6 +182,8 @@ export async function createCloudStack(config: CloudStackConfig): Promise<{
                     maxSize: Number(process.env.OS_KERNEL_CACHE_SIZE ?? kernelCacheSize ?? 32),
                     ttlMs: Number(process.env.OS_KERNEL_TTL_MS ?? kernelTtlMs ?? 15 * 60 * 1000),
                     cacheTTLMs: Number(process.env.OS_ENV_CACHE_TTL_MS ?? envCacheTtlMs ?? 5 * 60 * 1000),
+                    storage: storageEnv.storage,
+                    storageAdapterName: storageEnv.adapterName,
                 });
                 if (this._impl.init) await this._impl.init(ctx);
             } catch (err: any) {
@@ -206,7 +214,7 @@ export async function createCloudStack(config: CloudStackConfig): Promise<{
         // Falls back to local-FS adapter (rooted at OS_STORAGE_LOCAL_DIR or
         // <data-dir>/storage). On serverless without S3 env vars, the cloud-
         // artifact plugin will warn — set OS_STORAGE_ADAPTER=s3 in production.
-        ...(await resolveStoragePluginFromEnv()),
+        ...(storageEnv.plugin ? [storageEnv.plugin] : []),
         multiProjectPluginProxy,
         createStudioRuntimeConfigPlugin({ apiPrefix }),
         createTemplatesRoutePlugin(templateList, { apiPrefix }),

packages/services/service-cloud/src/multi-project-plugin.ts

@@ -51,6 +51,10 @@ export interface MultiProjectPluginConfig {
     cacheTTLMs?: number;
     maxSize?: number;
     ttlMs?: number;
+    /** Direct storage adapter for artifact publishing. Bypasses kernel.getService('file-storage'). */
+    storage?: any;
+    /** Adapter name (e.g. 's3', 'local') — used when persisting sys_project_revision rows. */
+    storageAdapterName?: string;
 }
 
 interface ExtractedItem {
@@ -287,6 +291,7 @@ function createTemplateSeeder(
                 bundleHasObjects: Array.isArray(bundle?.objects) ? bundle.objects.length : 0,
                 bundleHasApps: Array.isArray(bundle?.apps) ? bundle.apps.length : 0,
                 bundleHasViews: Array.isArray(bundle?.views) ? bundle.views.length : 0,
+                lastServiceKeys: (publishCtx as any)._lastServiceKeys ?? null,
             };
             if (!storage) {
                 publishStatus.error = 'no-file-storage-service';
@@ -335,10 +340,12 @@ function createTemplateSeeder(
                 : (cur?.metadata ?? {});
             await (publishCtx.controlDriver as any).update(
                 'sys_project',
-                { where: { id: projectId } },
+                projectId,
                 { metadata: JSON.stringify({ ...meta, publishStatus, publishStatusAt: new Date().toISOString() }) },
             );
-        } catch { /* best-effort diagnostic */ }
+        } catch (diagErr: any) {
+            console.error('[MultiProjectPlugin] Failed to write publishStatus diagnostic:', diagErr?.message ?? diagErr);
+        }
     };
 
     return {
@@ -352,15 +359,45 @@ function createTemplateSeeder(
         },
 
         async seed({ projectId, templateId }) {
+            const writeDiag = async (stage: string, extra: any = {}) => {
+                try {
+                    const cur = await (publishCtx.controlDriver as any).findOne('sys_project', { where: { id: projectId } });
+                    const meta = cur && typeof cur.metadata === 'string' ? JSON.parse(cur.metadata) : (cur?.metadata ?? {});
+                    const seedDiag = { ...(meta.seedDiag ?? {}), [stage]: { at: new Date().toISOString(), ...extra } };
+                    await (publishCtx.controlDriver as any).update('sys_project', projectId, {
+                        metadata: JSON.stringify({ ...meta, seedDiag }),
+                    });
+                } catch (e: any) { console.error('[MultiProjectPlugin] writeDiag failed', stage, e?.message); }
+            };
+            await writeDiag('seedCalled', { templateId, templates: Object.keys(templates) });
             const template = templates[templateId];
             if (!template) {
+                await writeDiag('seedNotFound', { templateId });
                 throw new Error(
                     `Unknown template: '${templateId}'. Available: [${Object.keys(templates).join(', ')}]`,
                 );
             }
-
-            const bundle = await template.load();
-            await seedBundleForProject(projectId, bundle);
+            let bundle: any;
+            try {
+                bundle = await template.load();
+                await writeDiag('templateLoaded', {
+                    objects: Array.isArray(bundle?.objects) ? bundle.objects.length : 'n/a',
+                    apps: Array.isArray(bundle?.apps) ? bundle.apps.length : 'n/a',
+                    views: Array.isArray(bundle?.views) ? bundle.views.length : 'n/a',
+                    data: Array.isArray(bundle?.data) ? bundle.data.length : 'n/a',
+                    bundleKeys: bundle ? Object.keys(bundle) : null,
+                });
+            } catch (e: any) {
+                await writeDiag('templateLoadError', { error: e?.message, stack: e?.stack?.split('\n').slice(0,5) });
+                throw e;
+            }
+            try {
+                await seedBundleForProject(projectId, bundle);
+                await writeDiag('seedBundleDone');
+            } catch (e: any) {
+                await writeDiag('seedBundleError', { error: e?.message, stack: e?.stack?.split('\n').slice(0,5) });
+                throw e;
+            }
         },
 
         async seedBundle({ projectId, bundle }) {
@@ -515,28 +552,34 @@ export class MultiProjectPlugin implements Plugin {
         });
         this.kernelManager = kernelManager;
 
+        const directStorage = this.config.storage ?? null;
+        const directStorageAdapter = this.config.storageAdapterName
+            ?? (process.env.OS_STORAGE_ADAPTER ?? 'local').toLowerCase();
         const seeder = createTemplateSeeder(
             kernelManager,
             this.config.templates ?? {},
             envRegistry,
             {
                 controlDriver: this.config.controlDriver,
-                storageAdapter: (process.env.OS_STORAGE_ADAPTER ?? 'local').toLowerCase(),
+                storageAdapter: directStorageAdapter,
                 keyPrefix: process.env.OS_STORAGE_KEY_PREFIX ?? 'artifacts',
                 getStorage: async () => {
-                    // Resolve once-per-call so the storage plugin (registered
-                    // in parallel) is available even when MultiProjectPlugin
-                    // initialised first. Try sync getService first; fall back
-                    // to async getServiceAsync (StorageServicePlugin may register
-                    // via async lifecycle on cold start).
+                    // 1. Direct storage adapter (preferred — set by cloud-stack
+                    //    via resolveStorageFromEnv to bypass kernel.getService
+                    //    lookup which is unreliable through the proxy wrapper).
+                    if (directStorage && typeof directStorage.upload === 'function') {
+                        return directStorage;
+                    }
+                    // 2. Fallback to kernel service lookup (for any stack that
+                    //    forgot to pass `storage` in MultiProjectPluginConfig).
                     try {
                         const sync = (hostKernel as any).getService?.('file-storage');
                         if (sync && typeof sync.upload === 'function') return sync;
-                    } catch { /* fall through */ }
+                    } catch { /* ignore */ }
                     try {
                         const async = await (hostKernel as any).getServiceAsync?.('file-storage');
                         if (async && typeof async.upload === 'function') return async;
-                    } catch { /* not registered yet */ }
+                    } catch { /* ignore */ }
                     return null;
                 },
             },

packages/services/service-cloud/src/storage-env.ts

@@ -26,10 +26,22 @@
  * fall back to its local-FS path with a startup warning.
  */
 export async function resolveStoragePluginFromEnv(): Promise<any[]> {
+    const r = await resolveStorageFromEnv();
+    return r.plugin ? [r.plugin] : [];
+}
+
+/**
+ * Same as {@link resolveStoragePluginFromEnv} but also returns the underlying
+ * storage adapter instance so callers can pass it to other plugins (e.g.
+ * MultiProjectPlugin's getStorage hook) without going through kernel service
+ * lookup. This avoids ordering / proxy issues where the host kernel's service
+ * registry doesn't surface 'file-storage' to closures captured during init.
+ */
+export async function resolveStorageFromEnv(): Promise<{ plugin: any | null; storage: any | null; adapterName: string }> {
     const adapter = (process.env.OS_STORAGE_ADAPTER ?? 'local').trim().toLowerCase();
 
     if (adapter === 'none' || adapter === 'disabled' || adapter === 'off') {
-        return [];
+        return { plugin: null, storage: null, adapterName: 'none' };
     }
 
     if (adapter === 's3') {
@@ -42,24 +54,24 @@ export async function resolveStoragePluginFromEnv(): Promise<any[]> {
                 'or set OS_STORAGE_ADAPTER=local for local development.',
             );
         }
-        const { StorageServicePlugin } = await import('@objectstack/service-storage');
-        return [new StorageServicePlugin({
-            adapter: 's3',
-            s3: {
-                bucket,
-                region,
-                endpoint: process.env.OS_S3_ENDPOINT?.trim() || undefined,
-                accessKeyId: process.env.OS_S3_ACCESS_KEY_ID?.trim() || undefined,
-                secretAccessKey: process.env.OS_S3_SECRET_ACCESS_KEY?.trim() || undefined,
-                forcePathStyle: /^(1|true|yes)$/i.test(process.env.OS_S3_FORCE_PATH_STYLE ?? ''),
-            },
-        })];
+        const { StorageServicePlugin, S3StorageAdapter } = await import('@objectstack/service-storage');
+        const s3Opts = {
+            bucket,
+            region,
+            endpoint: process.env.OS_S3_ENDPOINT?.trim() || undefined,
+            accessKeyId: process.env.OS_S3_ACCESS_KEY_ID?.trim() || undefined,
+            secretAccessKey: process.env.OS_S3_SECRET_ACCESS_KEY?.trim() || undefined,
+            forcePathStyle: /^(1|true|yes)$/i.test(process.env.OS_S3_FORCE_PATH_STYLE ?? ''),
+        };
+        const storage = new S3StorageAdapter(s3Opts);
+        const plugin = new StorageServicePlugin({ adapter: 's3', s3: s3Opts });
+        return { plugin, storage, adapterName: 's3' };
     }
 
     // 'local' (default)
-    const { StorageServicePlugin } = await import('@objectstack/service-storage');
-    return [new StorageServicePlugin({
-        adapter: 'local',
-        local: { rootDir: process.env.OS_STORAGE_LOCAL_DIR?.trim() || './storage' },
-    })];
+    const { StorageServicePlugin, LocalStorageAdapter } = await import('@objectstack/service-storage');
+    const rootDir = process.env.OS_STORAGE_LOCAL_DIR?.trim() || './storage';
+    const storage = new LocalStorageAdapter({ rootDir, basePath: '/api/v1/storage' });
+    const plugin = new StorageServicePlugin({ adapter: 'local', local: { rootDir } });
+    return { plugin, storage, adapterName: 'local' };
 }