castle-web-cli 0.4.112 → 0.4.114

package/dist/list-decks.js

@@ -5,12 +5,67 @@
 // The agent needs this because `add-import` takes a deck id, and until now
 // nothing told it which ids exist -- so it could only import a deck the user
 // had already named.
+//
+// Listing needs a Castle session, and there are two places one can be. A local
+// CLI has its own login. A cloud sandbox deliberately has NO token -- so there
+// we ask the browser that has this deck open, over the serve's WebSocket, and
+// the shell answers from its castle-www host (see shell/importApi.ts). Telling
+// a cloud user to `castle-web login` would be pointing at the wrong machine.
+import * as fs from 'fs';
 import * as path from 'path';
 import { listImportable } from './importBrowse.js';
+import { connectWS } from './preview.js';
 const KINDS = ['mine', 'saved', 'kits'];
+// The browser's answer travels on to castle-www and its GraphQL scans, so this
+// is the whole round trip, not one hop.
+const BROWSER_TIMEOUT_MS = 20_000;
 function isKind(value) {
     return KINDS.includes(value);
 }
+function serveWsPort(deckDir) {
+    try {
+        const raw = fs.readFileSync(path.join(deckDir, '.castle', 'serve.json'), 'utf8');
+        const port = JSON.parse(raw).wsPort;
+        return typeof port === 'number' ? port : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Null means nobody answered: no serve, or no browser on the other end of it.
+// A browser that answers "not signed in" is an ANSWER and comes back as one.
+async function askBrowser(deckDir, kind) {
+    const wsPort = serveWsPort(deckDir);
+    if (wsPort === null)
+        return null;
+    const ws = await connectWS(wsPort).catch(() => null);
+    if (!ws)
+        return null;
+    const requestId = Math.random().toString(36).slice(2);
+    const answer = new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(null), BROWSER_TIMEOUT_MS);
+        ws.on('message', (raw) => {
+            try {
+                const msg = JSON.parse(raw.toString());
+                if (msg.type !== 'import_list_response' || msg.requestId !== requestId)
+                    return;
+                clearTimeout(timer);
+                resolve(msg.list ?? null);
+            }
+            catch {
+                // the serve broadcasts other traffic on this socket; ignore what we
+                // can't read
+            }
+        });
+    });
+    ws.send(JSON.stringify({ type: 'import_list_request', requestId, tab: kind }));
+    try {
+        return await answer;
+    }
+    finally {
+        ws.close();
+    }
+}
 // One deck per line, id first: the id is what `add-import` takes, so it reads
 // straight out of the listing without the agent having to parse a sentence.
 function formatDeck(deck) {
@@ -27,9 +82,19 @@ export async function listDecks(dir, options = {}) {
         console.error(`Unknown kind "${kind}". Use one of: ${KINDS.join(', ')}.`);
         process.exit(1);
     }
-    const list = await listImportable(path.resolve(dir), kind);
+    const deckDir = path.resolve(dir);
+    const local = await listImportable(deckDir, kind);
+    const list = local.signedIn ? local : await askBrowser(deckDir, kind);
+    if (!list) {
+        // No serve at all means this is a plain local CLI, where the login is ours
+        // to have. With a serve up, the missing piece is a browser on it instead.
+        console.error(serveWsPort(deckDir) === null
+            ? 'Not signed in. Run `castle-web login` first.'
+            : 'Cannot list decks: nothing is connected to this deck in a browser, and the listing comes from the browser session. Open this deck in the editor and run this again.');
+        process.exit(1);
+    }
     if (!list.signedIn) {
-        console.error('Not signed in. Run `castle-web login` first.');
+        console.error('Cannot list decks: that browser is not signed in to Castle. Sign in and run this again.');
         process.exit(1);
     }
     if (list.decks.length === 0) {

package/dist/serve.js

@@ -149,7 +149,10 @@ function readDeckContext(projectDir) {
     }
 }
 const DEFAULT_PORT = 5757;
-const SCREENSHOT_REQUEST_TTL_MS = 15_000;
+// How long a forwarded request stays routable. Long enough for the slowest of
+// them (an import listing goes on to the browser's castle-www host and its
+// GraphQL scans); an unanswered id just sits in the map until this expires.
+const PENDING_REQUEST_TTL_MS = 30_000;
 function readServeJson(projectDir) {
     try {
         const raw = fs.readFileSync(path.join(projectDir, '.castle', 'serve.json'), 'utf8');
@@ -440,19 +443,41 @@ function startWSServer(port, projectDir, logFile, screenshotsDir, viteHolder) {
                             c.send(fwd);
                     }
                 }
-                if (msg.type === 'screenshot_request') {
+                // Things one client asks the OTHERS to answer: a tab's canvas for
+                // `screenshot`, and the browser's signed-in deck listing for
+                // `list-decks` (a cloud sandbox holds no Castle token; the browser
+                // that has the deck open does -- see shell/importApi.ts).
+                if (msg.type === 'screenshot_request' || msg.type === 'import_list_request') {
                     // Record the requester, then forward to the other clients (the tab).
                     if (typeof msg.requestId === 'string') {
                         forgetRequest(msg.requestId);
                         const timeout = setTimeout(() => {
                             requestOrigins.delete(msg.requestId);
-                        }, SCREENSHOT_REQUEST_TTL_MS);
+                        }, PENDING_REQUEST_TTL_MS);
                         requestOrigins.set(msg.requestId, { origin: ws, timeout });
                     }
                     const fwd = JSON.stringify(msg);
+                    let delivered = 0;
                     for (const c of clients) {
-                        if (c !== ws && c.readyState === WebSocket.OPEN)
+                        if (c !== ws && c.readyState === WebSocket.OPEN) {
                             c.send(fwd);
+                            delivered += 1;
+                        }
+                    }
+                    // Nobody to ask -- say so now rather than leaving the CLI to sit out
+                    // its whole timeout for an answer that can't come.
+                    if (delivered === 0 && msg.type === 'import_list_request' && typeof msg.requestId === 'string') {
+                        forgetRequest(msg.requestId);
+                        ws.send(JSON.stringify({ type: 'import_list_response', requestId: msg.requestId }));
+                    }
+                }
+                // The shell's answer, back to just the asker. A second tab answering
+                // the same request finds no pending origin and is dropped.
+                if (msg.type === 'import_list_response' && typeof msg.requestId === 'string') {
+                    const pending = requestOrigins.get(msg.requestId);
+                    forgetRequest(msg.requestId);
+                    if (pending && pending.origin.readyState === WebSocket.OPEN) {
+                        pending.origin.send(JSON.stringify(msg));
                     }
                 }
                 if (msg.type === 'log') {