sceneview-mcp 3.6.2 → 3.6.5

package/dist/billing.js

@@ -0,0 +1,137 @@
+// ─── Stripe Billing Validation for SceneView MCP Pro ─────────────────────────
+//
+// Validates API keys against Stripe subscriptions to determine tier access.
+// Uses native fetch() — no external Stripe SDK dependency.
+// MCP servers log to stderr (stdout is reserved for the JSON-RPC protocol).
+const cache = new Map();
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+function getCached(apiKey) {
+    const entry = cache.get(apiKey);
+    if (!entry)
+        return undefined;
+    if (Date.now() - entry.cachedAt > CACHE_TTL_MS) {
+        cache.delete(apiKey);
+        return undefined;
+    }
+    return entry.status;
+}
+function setCache(apiKey, status) {
+    cache.set(apiKey, { status, cachedAt: Date.now() });
+}
+/** Clears the validation cache. Useful for testing. */
+export function clearCache() {
+    cache.clear();
+}
+// ─── Development Allowlist ───────────────────────────────────────────────────
+const DEV_ALLOWLIST = new Set([
+    "dev_test_key",
+    "sceneview_dev",
+]);
+function checkDevAllowlist(apiKey) {
+    if (DEV_ALLOWLIST.has(apiKey)) {
+        return { valid: true, tier: "pro" };
+    }
+    return { valid: false, tier: "free", error: "Invalid API key (dev mode — no Stripe configured)" };
+}
+async function fetchStripeSubscription(subscriptionId, stripeSecretKey) {
+    const url = `https://api.stripe.com/v1/subscriptions/${encodeURIComponent(subscriptionId)}`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${stripeSecretKey}`,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { valid: false, tier: "free", error: `Stripe API request failed: ${message}` };
+    }
+    if (!response.ok) {
+        const body = await response.text().catch(() => "unknown error");
+        if (response.status === 404) {
+            return { valid: false, tier: "free", error: "Subscription not found" };
+        }
+        return {
+            valid: false,
+            tier: "free",
+            error: `Stripe API error (${response.status}): ${body}`,
+        };
+    }
+    let subscription;
+    try {
+        subscription = (await response.json());
+    }
+    catch {
+        return { valid: false, tier: "free", error: "Failed to parse Stripe response" };
+    }
+    const isActive = subscription.status === "active" || subscription.status === "trialing";
+    const expiresAt = new Date(subscription.current_period_end * 1000).toISOString();
+    if (isActive) {
+        return {
+            valid: true,
+            tier: "pro",
+            customerId: subscription.customer,
+            expiresAt,
+        };
+    }
+    return {
+        valid: false,
+        tier: "free",
+        customerId: subscription.customer,
+        expiresAt,
+        error: `Subscription status is "${subscription.status}" (expected "active" or "trialing")`,
+    };
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Validates an API key by checking it against Stripe subscriptions.
+ *
+ * - Results are cached in memory for 5 minutes to avoid excessive Stripe calls.
+ * - If `STRIPE_SECRET_KEY` is not set, falls back to a development allowlist.
+ * - The API key is treated as a Stripe subscription ID for the lookup.
+ */
+export async function validateApiKey(apiKey) {
+    // Check cache first
+    const cached = getCached(apiKey);
+    if (cached)
+        return cached;
+    let result;
+    if (isDevMode()) {
+        // No Stripe key configured — use allowlist for development/testing
+        result = checkDevAllowlist(apiKey);
+    }
+    else {
+        const stripeKey = process.env.STRIPE_SECRET_KEY;
+        result = await fetchStripeSubscription(apiKey, stripeKey);
+    }
+    setCache(apiKey, result);
+    return result;
+}
+/**
+ * Returns the configured SceneView API key from the environment, or undefined
+ * if the user is on the free tier (no key set).
+ */
+export function getConfiguredApiKey() {
+    return process.env.SCENEVIEW_API_KEY;
+}
+/**
+ * Returns true when `STRIPE_SECRET_KEY` is not set in the environment.
+ * In dev mode, API key validation falls back to a simple allowlist instead
+ * of calling the Stripe API.
+ */
+export function isDevMode() {
+    return !process.env.STRIPE_SECRET_KEY;
+}
+/**
+ * Records usage of an MCP tool for a given API key.
+ *
+ * Stub for future billing/metering integration. Currently logs to stderr
+ * (MCP servers must not write to stdout — it carries the JSON-RPC protocol).
+ */
+export async function recordUsage(apiKey, toolName) {
+    const timestamp = new Date().toISOString();
+    process.stderr.write(`[billing] ${timestamp} usage: key=${apiKey.slice(0, 8)}… tool=${toolName}\n`);
+}

package/dist/convert-platform.js

@@ -0,0 +1,302 @@
+/**
+ * convert-platform.ts
+ *
+ * Convert SceneView code between Android (Kotlin/Compose) and iOS (Swift/SwiftUI).
+ * Also generates multiplatform code from a scene description.
+ */
+const CONVERSION_RULES = [
+    {
+        pattern: /\bSceneView\s*\(/g,
+        androidToIos: "SceneView {",
+        iosToAndroid: "SceneView(",
+        description: "SceneView composable → SceneView SwiftUI view",
+    },
+    {
+        pattern: /\bARSceneView\s*\(/g,
+        androidToIos: "ARSceneView(",
+        iosToAndroid: "ARSceneView(",
+        description: "ARSceneView composable → ARSceneView SwiftUI view",
+    },
+    {
+        pattern: /rememberModelInstance\s*\(\s*modelLoader\s*,\s*"([^"]+)\.glb"\s*\)/g,
+        androidToIos: 'try await ModelNode.load("$1.usdz")',
+        iosToAndroid: 'rememberModelInstance(modelLoader, "$1.glb")',
+        description: "Model loading: rememberModelInstance → ModelNode.load, GLB → USDZ",
+    },
+    {
+        pattern: /rememberEngine\(\)/g,
+        androidToIos: "// Engine managed by RealityKit automatically",
+        iosToAndroid: "rememberEngine()",
+        description: "Engine: explicit in Android, implicit in iOS/RealityKit",
+    },
+    {
+        pattern: /rememberModelLoader\(engine\)/g,
+        androidToIos: "// ModelLoader not needed — RealityKit loads models directly",
+        iosToAndroid: "rememberModelLoader(engine)",
+        description: "ModelLoader: Android-specific, not needed on iOS",
+    },
+    {
+        pattern: /rememberEnvironmentLoader\(engine\)/g,
+        androidToIos: "// Environment managed by RealityKit automatically",
+        iosToAndroid: "rememberEnvironmentLoader(engine)",
+        description: "EnvironmentLoader: Android-specific",
+    },
+    {
+        pattern: /Modifier\.fillMaxSize\(\)/g,
+        androidToIos: ".edgesIgnoringSafeArea(.all)",
+        iosToAndroid: "Modifier.fillMaxSize()",
+        description: "Full-screen modifier",
+    },
+    {
+        pattern: /Position\(([^)]+)\)/g,
+        androidToIos: "SIMD3<Float>($1)",
+        iosToAndroid: "Position($1)",
+        description: "Position type: Position → SIMD3<Float>",
+    },
+    {
+        pattern: /\.glb\b/g,
+        androidToIos: ".usdz",
+        iosToAndroid: ".glb",
+        description: "Model format: GLB (Android) ↔ USDZ (iOS)",
+    },
+];
+export function convertAndroidToIos(code) {
+    let result = code;
+    const changes = [];
+    const warnings = [];
+    for (const rule of CONVERSION_RULES) {
+        if (rule.pattern.test(result)) {
+            const replacement = typeof rule.androidToIos === "string" ? rule.androidToIos : rule.androidToIos;
+            result = result.replace(new RegExp(rule.pattern.source, rule.pattern.flags), replacement);
+            changes.push(rule.description);
+        }
+    }
+    // Add Swift-specific warnings
+    warnings.push("RealityKit uses USDZ models, not GLB/glTF. Convert models using Apple's Reality Converter or Blender.");
+    warnings.push("RealityKit handles engine, material, and environment lifecycle automatically — no manual management needed.");
+    warnings.push("Swift async/await: model loading must use `try await` inside `.task { }` block.");
+    if (code.includes("LightNode")) {
+        warnings.push("LightNode API differs: RealityKit uses DirectionalLightComponent, PointLightComponent, SpotLightComponent on Entity.");
+    }
+    if (code.includes("materialLoader")) {
+        warnings.push("Material API differs: RealityKit uses SimpleMaterial, PhysicallyBasedMaterial, or UnlitMaterial.");
+    }
+    return { code: result, sourceplatform: "android", targetPlatform: "ios", changes, warnings };
+}
+export function convertIosToAndroid(code) {
+    let result = code;
+    const changes = [];
+    const warnings = [];
+    // iOS → Android specific replacements
+    const iosPatterns = [
+        { pattern: /SceneView\s*\{/g, replacement: "SceneView(engine = engine) {", description: "SceneView → SceneView with engine" },
+        { pattern: /ARSceneView\s*\(/g, replacement: "ARSceneView(engine = engine, ", description: "ARSceneView → ARSceneView with engine" },
+        { pattern: /try\s+await\s+ModelNode\.load\s*\(\s*"([^"]+)\.usdz"\s*\)/g, replacement: 'rememberModelInstance(modelLoader, "$1.glb")', description: "ModelNode.load → rememberModelInstance, USDZ → GLB" },
+        { pattern: /import\s+SwiftUI/g, replacement: "// SwiftUI → Jetpack Compose", description: "Import replacement" },
+        { pattern: /import\s+SceneViewSwift/g, replacement: "import io.github.sceneview.*", description: "Import replacement" },
+        { pattern: /import\s+RealityKit/g, replacement: "// RealityKit → Filament (included in SceneView)", description: "Import replacement" },
+        { pattern: /\.task\s*\{/g, replacement: "LaunchedEffect(Unit) {", description: ".task → LaunchedEffect" },
+        { pattern: /\.edgesIgnoringSafeArea\(.all\)/g, replacement: "", description: "Remove iOS-specific modifier" },
+        { pattern: /\.usdz\b/g, replacement: ".glb", description: "Model format: USDZ → GLB" },
+        { pattern: /@State\s+private\s+var/g, replacement: "var /* @State */ ", description: "@State → Compose state" },
+        { pattern: /SIMD3<Float>\(([^)]+)\)/g, replacement: "Position($1)", description: "SIMD3 → Position" },
+    ];
+    for (const rule of iosPatterns) {
+        if (rule.pattern.test(result)) {
+            result = result.replace(rule.pattern, rule.replacement);
+            changes.push(rule.description);
+        }
+    }
+    warnings.push("Android uses GLB/glTF models, not USDZ. Convert models using Blender or gltf-transform.");
+    warnings.push("Android requires explicit engine, modelLoader, and environmentLoader management.");
+    warnings.push("Filament JNI calls must run on the main thread. Use rememberModelInstance in composables.");
+    if (code.includes("Entity") || code.includes("entity")) {
+        warnings.push("RealityKit Entity → SceneView Node types (ModelNode, LightNode, etc.).");
+    }
+    return { code: result, sourceplatform: "ios", targetPlatform: "android", changes, warnings };
+}
+export function generateMultiplatformCode(description) {
+    const lower = description.toLowerCase();
+    const isAR = lower.includes("ar") || lower.includes("augmented") || lower.includes("camera");
+    const hasModel = lower.includes("model") || lower.includes("object") || lower.includes("3d") || !isAR;
+    const modelName = "scene_object";
+    const androidCode = isAR
+        ? `@Composable
+fun MultiplatformARScreen() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/${modelName}.glb")
+    var anchor by remember { mutableStateOf<Anchor?>(null) }
+
+    ARSceneView(
+        modifier = Modifier.fillMaxSize(),
+        engine = engine,
+        modelLoader = modelLoader,
+        planeRenderer = true,
+        sessionConfiguration = { session, config ->
+            config.lightEstimationMode = Config.LightEstimationMode.ENVIRONMENTAL_HDR
+            config.planeFindingMode = Config.PlaneFindingMode.HORIZONTAL_AND_VERTICAL
+        },
+        onTouchEvent = { event, hitResult ->
+            if (event.action == MotionEvent.ACTION_UP && hitResult != null) {
+                anchor = hitResult.createAnchor()
+            }
+            true
+        }
+    ) {
+        anchor?.let { a ->
+            AnchorNode(anchor = a) {
+                modelInstance?.let { instance ->
+                    ModelNode(
+                        modelInstance = instance,
+                        scaleToUnits = 0.5f,
+                        isEditable = true
+                    )
+                }
+            }
+        }
+    }
+}`
+        : `@Composable
+fun MultiplatformSceneScreen() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val environmentLoader = rememberEnvironmentLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/${modelName}.glb")
+
+    SceneView(
+        modifier = Modifier.fillMaxSize(),
+        engine = engine,
+        modelLoader = modelLoader,
+        environment = rememberEnvironment(environmentLoader) {
+            environmentLoader.createHDREnvironment("environments/sky_2k.hdr")
+                ?: createEnvironment(environmentLoader)
+        },
+        mainLightNode = rememberMainLightNode(engine) { intensity = 100_000f },
+        cameraManipulator = rememberCameraManipulator()
+    ) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 1.0f,
+                centerOrigin = Position(0f, 0f, 0f),
+                isEditable = true
+            )
+        }
+    }
+}`;
+    const iosCode = isAR
+        ? `import SwiftUI
+import SceneViewSwift
+import RealityKit
+
+struct MultiplatformARView: View {
+    @State private var model: ModelNode?
+
+    var body: some View {
+        ARSceneView(
+            planeDetection: .horizontal,
+            showCoachingOverlay: true,
+            onTapOnPlane: { position, arView in
+                guard let model else { return }
+                let anchor = AnchorNode.world(position: position)
+                let clone = model.entity.clone(recursive: true)
+                clone.scale = .init(repeating: 0.5)
+                anchor.add(clone)
+                arView.scene.addAnchor(anchor.entity)
+            }
+        )
+        .edgesIgnoringSafeArea(.all)
+        .task {
+            do {
+                model = try await ModelNode.load("models/${modelName}.usdz")
+            } catch {
+                print("Failed to load model: \\(error)")
+            }
+        }
+    }
+}`
+        : `import SwiftUI
+import SceneViewSwift
+import RealityKit
+
+struct MultiplatformSceneView: View {
+    @State private var model: ModelNode?
+
+    var body: some View {
+        SceneView { root in
+            if let model {
+                root.addChild(model.entity)
+            }
+        }
+        .cameraControls(.orbit)
+        .task {
+            do {
+                model = try await ModelNode.load("models/${modelName}.usdz")
+                model?.scaleToUnits(1.0)
+            } catch {
+                print("Failed to load model: \\(error)")
+            }
+        }
+    }
+}`;
+    return {
+        androidCode,
+        iosCode,
+        description,
+        notes: [
+            "Android uses GLB/glTF models, iOS uses USDZ format.",
+            "Both platforms render with PBR materials but use different engines (Filament vs RealityKit).",
+            "Android requires explicit engine/loader management; iOS/RealityKit handles this automatically.",
+            isAR ? "AR features: Android uses ARCore, iOS uses ARKit. Both support plane detection and anchoring." : "",
+            `Replace 'models/${modelName}.glb' and 'models/${modelName}.usdz' with your actual model files.`,
+        ].filter(Boolean),
+    };
+}
+export function formatConversionResult(result) {
+    const targetLabel = result.targetPlatform === "ios" ? "iOS (SwiftUI + RealityKit)" : "Android (Jetpack Compose + Filament)";
+    const lang = result.targetPlatform === "ios" ? "swift" : "kotlin";
+    const parts = [
+        `## Code Converted to ${targetLabel}`,
+        ``,
+        `**${result.changes.length} conversion(s) applied.**`,
+        ``,
+        `### Converted Code`,
+        ``,
+        "```" + lang,
+        result.code,
+        "```",
+        ``,
+    ];
+    if (result.changes.length > 0) {
+        parts.push(`### Changes`);
+        result.changes.forEach((c, i) => parts.push(`${i + 1}. ${c}`));
+        parts.push(``);
+    }
+    if (result.warnings.length > 0) {
+        parts.push(`### Manual Attention Required`);
+        result.warnings.forEach((w, i) => parts.push(`${i + 1}. ${w}`));
+    }
+    return parts.join("\n");
+}
+export function formatMultiplatformResult(result) {
+    return [
+        `## Multiplatform Scene Code`,
+        `**Description:** "${result.description}"`,
+        ``,
+        `### Android (Kotlin / Jetpack Compose)`,
+        ``,
+        "```kotlin",
+        result.androidCode,
+        "```",
+        ``,
+        `### iOS (Swift / SwiftUI)`,
+        ``,
+        "```swift",
+        result.iosCode,
+        "```",
+        ``,
+        `### Notes`,
+        ...result.notes.map((n, i) => `${i + 1}. ${n}`),
+    ].join("\n");
+}

package/dist/debug-issue.js

@@ -292,7 +292,7 @@ fun DebugModelViewer() {
         title: "Build / Gradle Errors",
         guide: `## Debugging: Build Errors
 
-### "Cannot resolve io.github.sceneview:sceneview:3.6.0"
+### "Cannot resolve io.github.sceneview:sceneview:3.6.2"
 
 1. Check repositories in \`settings.gradle.kts\`:
    \`\`\`kotlin
@@ -335,7 +335,7 @@ SceneView bundles Filament. If you also depend on Filament directly:
 \`\`\`kotlin
 // Remove direct Filament dependency — SceneView includes it
 // implementation("com.google.android.filament:filament-android:1.x.x") // REMOVE
-implementation("io.github.sceneview:sceneview:3.6.0") // This includes Filament
+implementation("io.github.sceneview:sceneview:3.6.2") // This includes Filament
 \`\`\`
 
 ### "Cannot find Filament material"