castle-web-cli 0.4.60 → 0.4.61

package/dist/castle-host/host.d.ts

@@ -26,6 +26,17 @@ export type GraphqlFetch = (
   variables: Record<string, unknown>,
 ) => Promise<GraphqlResponse>;
 
+export type PlatformHandler = (
+  command: unknown,
+  params: Record<string, unknown>,
+  ctx: HostContext,
+) => Promise<unknown>;
+
+export interface HostCapabilities {
+  graphqlFetch: GraphqlFetch;
+  platformHandler?: PlatformHandler;
+}
+
 export interface SerializedCommandError {
   code: string;
   message: string;
@@ -43,5 +54,5 @@ export function executeCommand(
   ctx: HostContext,
   command: unknown,
   params: unknown,
-  graphqlFetch: GraphqlFetch,
+  capabilities: HostCapabilities,
 ): Promise<HostResult>;

package/dist/castle-host/host.js

@@ -24,11 +24,22 @@ const COMMAND_NAMES = [
     "leaderboard.save",
     "user.getCurrent",
     "time.getServerTime",
+    "pass.has",
+    "pass.offer",
 ];
+// Platform/capability commands: NOT serviced by graphqlFetch. They're dispatched
+// to the host's optional platformHandler (mobile renders native UI; web shows an
+// upsell). A host with no platformHandler returns the command's normalized
+// "unavailable" outcome rather than an error — capability divergence is the
+// host's concern, never a deck-facing gate.
+const PLATFORM_COMMAND_NAMES = ["pass.offer"];
 function isCommandName(value) {
     return (typeof value === "string" &&
         COMMAND_NAMES.includes(value));
 }
+function isPlatformCommand(command) {
+    return PLATFORM_COMMAND_NAMES.includes(command);
+}
 class HostCommandError extends Error {
     code;
     command;
@@ -41,7 +52,7 @@ class HostCommandError extends Error {
         this.extensions = extensions;
     }
 }
-export async function executeCommand(ctx, command, params, graphqlFetch) {
+export async function executeCommand(ctx, command, params, capabilities) {
     if (!isCommandName(command)) {
         return {
             ok: false,
@@ -53,14 +64,18 @@ export async function executeCommand(ctx, command, params, graphqlFetch) {
         };
     }
     try {
-        const data = await runCommand(ctx, command, (params ?? {}), graphqlFetch);
+        const data = await runCommand(ctx, command, (params ?? {}), capabilities);
         return { ok: true, data };
     }
     catch (error) {
         return { ok: false, error: toSerializedError(error, command) };
     }
 }
-function runCommand(ctx, command, params, gql) {
+function runCommand(ctx, command, params, caps) {
+    if (isPlatformCommand(command)) {
+        return runPlatformCommand(ctx, command, params, caps);
+    }
+    const gql = caps.graphqlFetch;
     switch (command) {
         case "deckStorage.load":
             return deckStorageLoad(ctx, gql);
@@ -78,7 +93,68 @@ function runCommand(ctx, command, params, gql) {
             return Promise.resolve(userGetCurrent(ctx));
         case "time.getServerTime":
             return timeGetServerTime(gql);
+        case "pass.has":
+            return passHas(ctx, params, gql);
+        // Platform commands are handled above; listed here to keep the switch
+        // exhaustive over CommandName.
+        case "pass.offer":
+            return runPlatformCommand(ctx, command, params, caps);
+    }
+}
+// Dispatch a platform/capability command to the host's platformHandler. No
+// handler → the command's normalized "unavailable" outcome (a SUCCESS, not an
+// error: a deck on a host without this capability still gets one uniform
+// result). The handler's return is normalized so a malformed outcome can't
+// leak through to the deck.
+async function runPlatformCommand(ctx, command, params, caps) {
+    switch (command) {
+        case "pass.offer":
+            return passesOffer(ctx, params, caps);
+        default:
+            return unavailableOutcome(command);
+    }
+}
+async function passHas(ctx, params, gql) {
+    const deckId = requireDeckId(ctx, "pass.has");
+    const passId = asString(params.passId, "passId", "pass.has");
+    const data = await graphql(gql, PASSES_FOR_DECK_QUERY, { deckId }, "pass.has");
+    const match = (data.passesForDeck ?? []).find((p) => p?.passId === passId);
+    return { hasPass: match?.isActive === true };
+}
+async function passesOffer(ctx, params, caps) {
+    const passId = asString(params.passId, "passId", "pass.offer");
+    // Hosts without bricks support (dev CLI — no handler at all) get a normalized
+    // unavailable, never an error or a thrown MISSING_DECK_ID.
+    if (!caps.platformHandler)
+        return { status: "unavailable" };
+    // Real transaction path (mobile native sheet; web upsell): the pass belongs
+    // to a deck, so a trusted deckId is required before handing off.
+    const deckId = requireDeckId(ctx, "pass.offer");
+    const outcome = await caps.platformHandler("pass.offer", { passId, deckId }, ctx);
+    return normalizePassOutcome(outcome);
+}
+function normalizePassOutcome(value) {
+    const record = typeof value === "object" && value !== null
+        ? value
+        : {};
+    const status = record.status;
+    const valid = [
+        "purchased",
+        "alreadyOwned",
+        "cancelled",
+        "unavailable",
+    ];
+    if (typeof status === "string" && valid.includes(status)) {
+        return { status: status };
+    }
+    return { status: "cancelled" };
+}
+function unavailableOutcome(command) {
+    // Only passes exists today; keep this total over future platform commands.
+    if (command === "pass.offer") {
+        return { status: "unavailable" };
     }
+    return { status: "unavailable" };
 }
 async function deckStorageLoad(ctx, gql) {
     const deckId = requireDeckId(ctx, "deckStorage.load");
@@ -362,6 +438,14 @@ const SAVE_LEADERBOARD_MUTATION = `
     )
   }
 `;
+const PASSES_FOR_DECK_QUERY = `
+  query CastlePassesForDeck($deckId: ID!) {
+    passesForDeck(deckId: $deckId) {
+      passId
+      isActive
+    }
+  }
+`;
 const SERVER_TIME_QUERY = `
   query CastleServerTime {
     serverTime {

package/dist/ide.js

@@ -670,6 +670,9 @@ const IDE_STYLES = `
     margin-top: 6px;
     max-height: 65px;
     overflow-y: auto;
+    /* Hide the scrollbar (Windows draws a persistent one; macOS auto-hides). */
+    scrollbar-width: none;
+    -ms-overflow-style: none;
     font-size: 12px;
     line-height: 1.5;
     color: #57606a;
@@ -683,6 +686,7 @@ const IDE_STYLES = `
     );
     mask-image: linear-gradient(to bottom, transparent, #000000 5px, #000000 100%);
   }
+  .task-feed::-webkit-scrollbar { width: 0; height: 0; }
   .task-row { display: flex; align-items: center; gap: 8px; }
   .task-title {
     flex: 1 1 auto;

package/dist/serve.js

@@ -93,7 +93,10 @@ async function devHostContext(projectDir) {
 }
 async function handleCastleCommand(ws, projectDir, requestId, command, params) {
     const ctx = await devHostContext(projectDir);
-    const result = await executeCommand(ctx, command, params, castleGraphql);
+    // The dev server services data commands via GraphQL but supplies no
+    // platformHandler, so platform/capability commands (e.g. passes.purchase)
+    // resolve to their normalized "unavailable" outcome.
+    const result = await executeCommand(ctx, command, params, { graphqlFetch: castleGraphql });
     if (ws.readyState === WebSocket.OPEN) {
         ws.send(JSON.stringify({ type: 'castle_command_response', castleSdk: 1, requestId, ...result }));
     }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.60",
+  "version": "0.4.61",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"
   },
   "scripts": {
-    "build": "tsc && cp -R src/castle-host dist/castle-host && rm -rf kits && cp -R ../kits kits",
+    "build": "tsc && rm -rf dist/castle-host && cp -R src/castle-host dist/castle-host && rm -rf kits && cp -R ../kits kits",
     "dev": "tsc --watch",
     "check": "eslint . && jscpd && tsc --noEmit"
   },