@series-inc/stowkit-cli 0.6.34 → 0.6.36

package/dist/gcs.js

@@ -1,69 +1,4 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as crypto from 'node:crypto';
-// ─── JWT Auth ────────────────────────────────────────────────────────────────
-function base64url(data) {
-    const buf = typeof data === 'string' ? Buffer.from(data) : data;
-    return buf.toString('base64url');
-}
-function createJWT(sa) {
-    const now = Math.floor(Date.now() / 1000);
-    const header = { alg: 'RS256', typ: 'JWT' };
-    const payload = {
-        iss: sa.client_email,
-        scope: 'https://www.googleapis.com/auth/devstorage.read_write',
-        aud: 'https://oauth2.googleapis.com/token',
-        iat: now,
-        exp: now + 3600,
-    };
-    const segments = `${base64url(JSON.stringify(header))}.${base64url(JSON.stringify(payload))}`;
-    const sign = crypto.createSign('RSA-SHA256');
-    sign.update(segments);
-    const signature = sign.sign(sa.private_key);
-    return `${segments}.${base64url(signature)}`;
-}
-async function getAccessToken(sa) {
-    const jwt = createJWT(sa);
-    const res = await fetch('https://oauth2.googleapis.com/token', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-        body: `grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=${jwt}`,
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`GCS auth failed (${res.status}): ${text}`);
-    }
-    const data = await res.json();
-    return data.access_token;
-}
-// ─── Credential Resolution ───────────────────────────────────────────────────
-async function loadServiceAccount(projectDir) {
-    // Search order: project dir, cwd, GOOGLE_APPLICATION_CREDENTIALS env
-    const candidates = [
-        path.join(projectDir, 'service_account.json'),
-        path.join(process.cwd(), 'service_account.json'),
-    ];
-    for (const candidate of candidates) {
-        try {
-            const text = await fs.readFile(candidate, 'utf-8');
-            return JSON.parse(text);
-        }
-        catch { /* not found */ }
-    }
-    // Fall back to GOOGLE_APPLICATION_CREDENTIALS
-    const envPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-    if (envPath) {
-        try {
-            const text = await fs.readFile(envPath, 'utf-8');
-            return JSON.parse(text);
-        }
-        catch {
-            throw new Error(`Could not read service account from GOOGLE_APPLICATION_CREDENTIALS: ${envPath}`);
-        }
-    }
-    throw new Error('No GCS credentials found. Place service_account.json in project root, ' +
-        'current directory, or set GOOGLE_APPLICATION_CREDENTIALS environment variable.');
-}
+import { loadServiceAccount, getAccessToken, GCS_SCOPE } from './gcp-auth.js';
 // ─── Bucket Name Parsing ─────────────────────────────────────────────────────
 function parseBucket(bucketUri) {
     // Accept "gs://bucket-name" or just "bucket-name"
@@ -74,7 +9,7 @@ function parseBucket(bucketUri) {
 // ─── GCS Client Factory ─────────────────────────────────────────────────────
 export async function createGCSClient(projectDir, bucketUri) {
     const sa = await loadServiceAccount(projectDir);
-    const token = await getAccessToken(sa);
+    const token = await getAccessToken(sa, [GCS_SCOPE]);
     const bucket = parseBucket(bucketUri);
     const apiBase = `https://storage.googleapis.com`;
     return {
@@ -109,50 +44,5 @@ export async function createGCSClient(projectDir, bucketUri) {
             }
             return res.text();
         },
-        async downloadWithGeneration(objectPath) {
-            const encoded = encodeURIComponent(objectPath);
-            const url = `${apiBase}/storage/v1/b/${bucket}/o/${encoded}?alt=media`;
-            const res = await fetch(url, {
-                headers: { Authorization: `Bearer ${token}` },
-            });
-            if (res.status === 404)
-                return null;
-            if (!res.ok) {
-                const text = await res.text();
-                throw new Error(`GCS download failed for ${objectPath} (${res.status}): ${text}`);
-            }
-            const data = await res.text();
-            const generation = res.headers.get('x-goog-generation') ?? '0';
-            return { data, generation };
-        },
-        async uploadWithGeneration(objectPath, data, generation, contentType = 'application/json') {
-            const encoded = encodeURIComponent(objectPath);
-            let url = `${apiBase}/upload/storage/v1/b/${bucket}/o?uploadType=media&name=${encoded}`;
-            const headers = {
-                Authorization: `Bearer ${token}`,
-                'Content-Type': contentType,
-            };
-            // Optimistic concurrency: if we have a generation, require it to match
-            if (generation) {
-                headers['x-goog-if-generation-match'] = generation;
-            }
-            else {
-                // Object should not exist yet
-                headers['x-goog-if-generation-match'] = '0';
-            }
-            const res = await fetch(url, {
-                method: 'POST',
-                headers,
-                body: data,
-            });
-            if (res.status === 412) {
-                throw new Error(`Registry was modified by another publish while uploading. ` +
-                    `Please retry the publish command.`);
-            }
-            if (!res.ok) {
-                const text = await res.text();
-                throw new Error(`GCS upload failed for ${objectPath} (${res.status}): ${text}`);
-            }
-        },
     };
 }

package/dist/index.d.ts

@@ -30,5 +30,7 @@ export { syncRuntimeAssets } from './sync-runtime-assets.js';
 export { publishPackage } from './publish.js';
 export type { PublishOptions, PublishResult } from './publish.js';
 export * from './assets-package.js';
-export { fetchRegistry, searchAssets, listPackages, resolveAssetDeps } from './store.js';
+export { searchAssets, listStorePackages, resolveAssetDeps } from './store.js';
 export type { SearchResult, PackageInfo } from './store.js';
+export { createFirestoreReader, createFirestoreClient } from './firestore.js';
+export type { FirestoreReader, FirestoreClient, FirestorePackageDoc, FirestoreVersionDoc } from './firestore.js';

package/dist/index.js

@@ -39,4 +39,6 @@ export { syncRuntimeAssets } from './sync-runtime-assets.js';
 export { publishPackage } from './publish.js';
 export * from './assets-package.js';
 // Store
-export { fetchRegistry, searchAssets, listPackages, resolveAssetDeps } from './store.js';
+export { searchAssets, listStorePackages, resolveAssetDeps } from './store.js';
+// Firestore
+export { createFirestoreReader, createFirestoreClient } from './firestore.js';

package/dist/init.js

@@ -95,6 +95,7 @@ export async function initProject(projectDir, opts) {
     const stowkitIgnores = [
         '# StowKit',
         '*.stowcache',
+        '.stow-thumbnails/',
         'public/cdn-assets/',
         'Open Packer.bat',
         'open-packer.sh',
@@ -104,6 +105,16 @@ export async function initProject(projectDir, opts) {
         if (!existing.includes('*.stowcache')) {
             await fs.writeFile(gitignorePath, existing.trimEnd() + '\n\n' + stowkitIgnores + '\n');
         }
+        else {
+            // Existing project — ensure newer ignore entries are present
+            let updated = existing;
+            if (!existing.includes('.stow-thumbnails/')) {
+                updated = updated.trimEnd() + '\n.stow-thumbnails/\n';
+            }
+            if (updated !== existing) {
+                await fs.writeFile(gitignorePath, updated);
+            }
+        }
     }
     catch {
         await fs.writeFile(gitignorePath, stowkitIgnores + '\n');
@@ -118,35 +129,135 @@ export async function initProject(projectDir, opts) {
     console.log(`  Config:         .felicityproject`);
     console.log(`  AI skills:      .claude/skills/stowkit/SKILL.md, .cursor/rules/stowkit.mdc`);
     console.log(`  Launcher:       Open Packer.bat (Windows) / open-packer.sh (macOS/Linux)`);
+    // Add engine-specific gitignore entries
+    if (withEngine) {
+        const engineIgnores = [
+            '# Engine (generated by postinstall)',
+            'node_modules/',
+            'dist/',
+            'public/basis/',
+            'public/stowkit/',
+            'public/stowkit_reader.wasm',
+        ].join('\n');
+        try {
+            const existing = await fs.readFile(gitignorePath, 'utf-8');
+            if (!existing.includes('public/stowkit_reader.wasm')) {
+                await fs.writeFile(gitignorePath, existing.trimEnd() + '\n\n' + engineIgnores + '\n');
+            }
+        }
+        catch {
+            // gitignore should exist from earlier step, but handle gracefully
+        }
+    }
     // Install engine if selected
     if (withEngine) {
         await installEngine(absDir);
     }
     console.log('');
-    console.log('Drop your assets (PNG, JPG, FBX, WAV, etc.) into assets/');
-    console.log('Then run: stowkit build');
-    console.log('Or double-click "Open Packer.bat" to launch the packer GUI.');
+    if (withEngine) {
+        console.log('Ready to go! Run:');
+        console.log('  npm run dev');
+    }
+    else {
+        console.log('Drop your assets (PNG, JPG, FBX, WAV, etc.) into assets/');
+        console.log('Then run: stowkit build');
+        console.log('Or double-click "Open Packer.bat" to launch the packer GUI.');
+    }
+}
+async function copyTemplateFiles(templateDir, targetDir) {
+    const copied = [];
+    const entries = await fs.readdir(templateDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = path.join(templateDir, entry.name);
+        const dest = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            const sub = await copyTemplateFiles(src, dest);
+            copied.push(...sub);
+        }
+        else {
+            // Skip package.json — handled separately via merge logic
+            if (entry.name === 'package.json')
+                continue;
+            try {
+                await fs.access(dest);
+                // File exists — don't clobber
+            }
+            catch {
+                await fs.mkdir(path.dirname(dest), { recursive: true });
+                await fs.copyFile(src, dest);
+                copied.push(path.relative(targetDir, dest));
+            }
+        }
+    }
+    return copied;
+}
+async function mergePackageJson(templatePkgPath, targetDir) {
+    const templatePkg = JSON.parse(await fs.readFile(templatePkgPath, 'utf-8'));
+    const targetPkgPath = path.join(targetDir, 'package.json');
+    let targetPkg;
+    try {
+        targetPkg = JSON.parse(await fs.readFile(targetPkgPath, 'utf-8'));
+    }
+    catch {
+        // No existing package.json — use template as-is
+        templatePkg.name = path.basename(targetDir);
+        await fs.writeFile(targetPkgPath, JSON.stringify(templatePkg, null, 2) + '\n');
+        return;
+    }
+    // Merge scripts (don't overwrite existing scripts)
+    targetPkg.scripts = { ...templatePkg.scripts, ...targetPkg.scripts };
+    // Ensure postinstall includes copy-decoders
+    if (!targetPkg.scripts.postinstall?.includes('copy-decoders')) {
+        targetPkg.scripts.postinstall = templatePkg.scripts.postinstall;
+    }
+    // Merge dependencies
+    for (const depType of ['dependencies', 'devDependencies', 'peerDependencies']) {
+        if (templatePkg[depType]) {
+            targetPkg[depType] = { ...templatePkg[depType], ...(targetPkg[depType] ?? {}) };
+        }
+    }
+    // Ensure type: module
+    if (!targetPkg.type)
+        targetPkg.type = 'module';
+    await fs.writeFile(targetPkgPath, JSON.stringify(targetPkg, null, 2) + '\n');
 }
 async function installEngine(absDir) {
+    const thisDir = path.dirname(fileURLToPath(import.meta.url));
+    const templateDir = path.resolve(thisDir, '../templates/engine');
+    // Verify template directory exists
+    try {
+        await fs.access(templateDir);
+    }
+    catch {
+        console.error('Engine template not found. Please update @series-inc/stowkit-cli.');
+        return;
+    }
     console.log('');
-    console.log('Installing @series-inc/rundot-3d-engine and three...');
+    console.log('Setting up 3D engine project...');
+    // Copy template files (skip existing, skip package.json)
+    const copied = await copyTemplateFiles(templateDir, absDir);
+    if (copied.length > 0) {
+        console.log(`  Created: ${copied.join(', ')}`);
+    }
+    // Merge or create package.json
+    await mergePackageJson(path.join(templateDir, 'package.json'), absDir);
+    // Install dependencies
+    console.log('  Installing dependencies...');
     const { execSync } = await import('node:child_process');
     try {
-        execSync('npm install @series-inc/rundot-3d-engine three', {
+        execSync('npm install', {
             cwd: absDir,
             stdio: 'inherit',
         });
     }
     catch {
-        console.error('Failed to install engine packages. You can install manually:');
-        console.error('  npm install @series-inc/rundot-3d-engine three');
+        console.error('Failed to install dependencies. Run `npm install` manually.');
         return;
     }
+    // Copy engine skill files
     await copyEngineSkillFiles(absDir);
     console.log('');
-    console.log('  3D Engine installed:');
-    console.log('    @series-inc/rundot-3d-engine');
-    console.log('    three');
+    console.log('  3D Engine project ready!');
     console.log('  AI skills: .claude/skills/stowkit-engine/SKILL.md, .cursor/rules/stowkit-engine.mdc');
 }
 async function copySkillFiles(absDir) {

package/dist/publish.js

@@ -1,7 +1,8 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { readProjectConfig, scanDirectory } from './node-fs.js';
-import { readAssetsPackage, initAssetsPackage, createEmptyRegistry, } from './assets-package.js';
+import { readAssetsPackage, initAssetsPackage, } from './assets-package.js';
+import { createFirestoreClient } from './firestore.js';
 import { createGCSClient } from './gcs.js';
 import { readStowmeta } from './app/stowmeta-io.js';
 // ─── Build full dependency graph from srcArtDir ──────────────────────────────
@@ -145,7 +146,7 @@ export async function publishPackage(projectDir, opts = {}) {
     const bucketUri = opts.bucket
         ?? pkg.bucket
         ?? process.env.STOWKIT_BUCKET
-        ?? 'gs://venus-shared-assets-test';
+        ?? 'gs://rungame-shared-assets-test';
     log(`Bucket: ${bucketUri}`);
     // Step 4: Scan srcArtDir
     const scan = await scanDirectory(project.srcArtDir);
@@ -252,29 +253,15 @@ export async function publishPackage(projectDir, opts = {}) {
     }
     // Step 7: Create GCS client and auth
     const emitProgress = opts.onProgress ?? (() => { });
-    const totalUploads = filesToUpload.length + Object.keys(thumbMap).length + 2; // +2 for assets-package.json and registry.json
+    const totalUploads = filesToUpload.length + Object.keys(thumbMap).length + 2; // +2 for assets-package.json and Firestore writes
     let totalDone = 0;
     log('Authenticating with GCS...');
     emitProgress({ phase: 'auth', done: 0, total: totalUploads, message: 'Authenticating with GCS...' });
     const gcs = await createGCSClient(projectDir, bucketUri);
-    // Step 8: Download current registry
-    log('Fetching registry...');
-    const registryResult = await gcs.downloadWithGeneration('registry.json');
-    let registry;
-    let generation;
-    if (registryResult) {
-        registry = JSON.parse(registryResult.data);
-        generation = registryResult.generation;
-        vlog(`Registry loaded (generation: ${generation})`);
-    }
-    else {
-        registry = createEmptyRegistry();
-        generation = null;
-        vlog('No existing registry — will create new one');
-    }
-    // Step 9: Check version not already published
-    const existingPkg = registry.packages[pkg.name];
-    if (existingPkg?.versions[pkg.version] && !opts.force) {
+    // Step 8: Create Firestore client and check version
+    const firestore = await createFirestoreClient(projectDir);
+    const existingVer = await firestore.getVersion(pkg.name, pkg.version);
+    if (existingVer && !opts.force) {
         throw new Error(`Version ${pkg.version} of "${pkg.name}" is already published. ` +
             `Bump the version in assets-package.json or use --force to overwrite.`);
     }
@@ -338,27 +325,17 @@ export async function publishPackage(projectDir, opts = {}) {
         }
         catch { /* file doesn't exist, try next */ }
     }
-    // Step 13: Update and upload registry
+    // Step 13: Write to Firestore
     log('Updating registry...');
-    if (!registry.packages[pkg.name]) {
-        registry.packages[pkg.name] = {
-            description: pkg.description,
-            author: pkg.author,
-            tags: pkg.tags ?? [],
-            latest: pkg.version,
-            versions: {},
-        };
-    }
-    const regPkg = registry.packages[pkg.name];
-    regPkg.versions[pkg.version] = versionEntry;
-    regPkg.latest = pkg.version;
-    regPkg.description = pkg.description;
-    regPkg.author = pkg.author;
-    regPkg.tags = pkg.tags ?? [];
-    if (packThumbnail)
-        regPkg.thumbnail = packThumbnail;
     emitProgress({ phase: 'registry', done: totalDone, total: totalUploads, message: 'Updating registry...' });
-    await gcs.uploadWithGeneration('registry.json', JSON.stringify(registry, null, 2), generation);
+    await firestore.setVersion(pkg.name, pkg.version, versionEntry);
+    await firestore.setPackage(pkg.name, {
+        description: pkg.description,
+        author: pkg.author,
+        tags: pkg.tags ?? [],
+        latest: pkg.version,
+        thumbnail: packThumbnail ?? null,
+    });
     totalDone++;
     emitProgress({ phase: 'registry', done: totalDone, total: totalUploads, message: 'Done' });
     log(`\nPublished ${pkg.name}@${pkg.version} successfully!`);