@playdrop/playdrop-cli 0.5.2 → 0.5.4

package/dist/commands/devServer.js

@@ -3,12 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_ROUTER_PORT = void 0;
+exports.parseMountConflictError = parseMountConflictError;
+exports.buildLocalDevAppUrl = buildLocalDevAppUrl;
+exports.ensureDevRouterRunning = ensureDevRouterRunning;
 exports.startDevServer = startDevServer;
 exports.isDevServerAvailable = isDevServerAvailable;
+exports.runDevRouterServer = runDevRouterServer;
 const node_http_1 = __importDefault(require("node:http"));
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+exports.DEV_ROUTER_PORT = 8888;
+const DEV_ROUTER_HOST = '127.0.0.1';
+const CONTROL_PREFIX = '/_playdrop';
 const CONTENT_TYPE_BY_EXTENSION = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'application/javascript; charset=utf-8',
@@ -27,14 +36,57 @@ const CONTENT_TYPE_BY_EXTENSION = {
     '.mp4': 'video/mp4',
     '.webm': 'video/webm',
 };
+const routerMountsById = new Map();
+const routerMountIdsByKey = new Map();
 function resolveContentType(filePath) {
     const extension = (0, node_path_1.extname)(filePath).toLowerCase();
     return CONTENT_TYPE_BY_EXTENSION[extension] || 'application/octet-stream';
 }
+function getCliEntrypointPath() {
+    return (0, node_path_1.resolve)(__dirname, '..', 'index.js');
+}
+function buildMountKey(creatorUsername, appType, appName) {
+    return `${creatorUsername}:${appType}:${appName}`;
+}
+function encodeMountConflictError(details) {
+    const encoded = Buffer.from(JSON.stringify(details), 'utf8').toString('base64url');
+    return `mount_conflict:${encoded}`;
+}
+function parseMountConflictError(message) {
+    if (!message.startsWith('mount_conflict:')) {
+        return null;
+    }
+    try {
+        const decoded = Buffer.from(message.slice('mount_conflict:'.length), 'base64url').toString('utf8');
+        const payload = JSON.parse(decoded);
+        if (typeof payload.ref !== 'string'
+            || typeof payload.ownerPid !== 'number'
+            || !Number.isInteger(payload.ownerPid)
+            || payload.ownerPid <= 0
+            || typeof payload.repoRoot !== 'string'
+            || typeof payload.htmlPath !== 'string') {
+            return null;
+        }
+        return {
+            ref: payload.ref,
+            ownerPid: payload.ownerPid,
+            repoRoot: payload.repoRoot,
+            htmlPath: payload.htmlPath,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function buildLocalDevAppUrl(input) {
+    const port = input.port ?? exports.DEV_ROUTER_PORT;
+    return `http://${DEV_ROUTER_HOST}:${port}/apps/dev/${encodeURIComponent(input.creatorUsername)}/${encodeURIComponent(input.appType)}/${encodeURIComponent(input.appName)}/index.html`;
+}
 function respondWithBuffer(res, method, statusCode, contentType, payload) {
     res.statusCode = statusCode;
     res.setHeader('Content-Type', contentType);
     res.setHeader('Content-Length', String(payload.length));
+    res.setHeader('Cache-Control', 'no-store');
     if (method === 'HEAD') {
         res.end();
         return;
@@ -45,6 +97,37 @@ function respondWithText(res, method, statusCode, message) {
     const payload = Buffer.from(message, 'utf8');
     respondWithBuffer(res, method, statusCode, 'text/plain; charset=utf-8', payload);
 }
+function sendJson(res, statusCode, payload) {
+    const body = Buffer.from(JSON.stringify(payload), 'utf8');
+    respondWithBuffer(res, 'GET', statusCode, 'application/json; charset=utf-8', body);
+}
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function removeRouterMount(mountId) {
+    const mount = routerMountsById.get(mountId);
+    if (!mount) {
+        return;
+    }
+    routerMountsById.delete(mountId);
+    routerMountIdsByKey.delete(mount.key);
+}
+function cleanupStaleRouterMounts() {
+    for (const [mountId, mount] of routerMountsById.entries()) {
+        if (!isPidAlive(mount.ownerPid)) {
+            removeRouterMount(mountId);
+        }
+    }
+}
 function resolveStaticPath(staticRoot, rawRelativePath) {
     const normalizedRelativePath = (0, node_path_1.normalize)(rawRelativePath.replace(/^\/+/, ''));
     if (!normalizedRelativePath || normalizedRelativePath === '.' || normalizedRelativePath.startsWith('..')) {
@@ -57,36 +140,227 @@ function resolveStaticPath(staticRoot, rawRelativePath) {
     }
     return absolutePath;
 }
+function parseMountPath(pathname) {
+    if (!pathname.startsWith('/apps/dev/')) {
+        return null;
+    }
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments.length < 6) {
+        return null;
+    }
+    // filter(Boolean) removes the leading empty segment from absolute paths, so the
+    // creator tuple starts at indices 2..4 for /apps/dev/<creator>/<type>/<name>/...
+    const [, , creatorUsername, appType, appName, ...rest] = segments;
+    if (!creatorUsername || !appType || !appName || rest.length === 0) {
+        return null;
+    }
+    return {
+        key: buildMountKey(decodeURIComponent(creatorUsername), decodeURIComponent(appType), decodeURIComponent(appName)),
+        assetPath: rest.map((entry) => decodeURIComponent(entry)).join('/'),
+    };
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString('utf8').trim();
+    return raw ? JSON.parse(raw) : {};
+}
 function spawnDevScript(projectInfo) {
     if (!projectInfo.projectDir || !projectInfo.packageJson || typeof projectInfo.packageJson.scripts?.dev !== 'string') {
         return null;
     }
     const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    const projectLabel = (0, node_path_1.relative)(process.cwd(), projectInfo.projectDir) || projectInfo.projectDir;
-    console.log(`▶ Running "npm run dev" in ${projectLabel}`);
     const child = (0, node_child_process_1.spawn)(npmCommand, ['run', 'dev'], {
         cwd: projectInfo.projectDir,
         stdio: 'inherit',
         env: { ...process.env },
     });
-    child.on('exit', code => {
-        if (code !== 0) {
-            console.warn(`npm run dev exited with code ${code}.`);
+    return child;
+}
+async function fetchRouterJson(path, init = {}, port = exports.DEV_ROUTER_PORT) {
+    const response = await fetch(`http://${DEV_ROUTER_HOST}:${port}${path}`, init);
+    if (!response.ok) {
+        if (response.status === 404) {
+            return null;
+        }
+        const payload = await response.json().catch(() => null);
+        throw new Error(typeof payload?.error === 'string'
+            ? payload.error
+            : `router_request_failed:${response.status}`);
+    }
+    return await response.json();
+}
+async function isRouterHealthy(port = exports.DEV_ROUTER_PORT, timeoutMs = 400) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    timeout.unref?.();
+    try {
+        const response = await fetch(`http://${DEV_ROUTER_HOST}:${port}${CONTROL_PREFIX}/health`, {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function ensureDevRouterRunning(port = exports.DEV_ROUTER_PORT) {
+    if (await isRouterHealthy(port)) {
+        return;
+    }
+    const cliEntrypoint = getCliEntrypointPath();
+    const child = (0, node_child_process_1.spawn)(process.execPath, [cliEntrypoint, 'project', '_dev-router', 'serve'], {
+        detached: true,
+        stdio: 'ignore',
+        env: {
+            ...process.env,
+            PLAYDROP_DEV_ROUTER_PORT: String(port),
+        },
+    });
+    child.unref();
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        if (await isRouterHealthy(port, 250)) {
+            return;
         }
+        await new Promise((resolveTimeout) => setTimeout(resolveTimeout, 150));
+    }
+    throw new Error('dev_router_start_failed');
+}
+async function registerDevMount(input, port = exports.DEV_ROUTER_PORT) {
+    const response = await fetch(`http://${DEV_ROUTER_HOST}:${port}${CONTROL_PREFIX}/mounts`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(input),
     });
-    return child;
+    const payload = await response.json().catch(() => null);
+    if (!response.ok || !payload) {
+        throw new Error(`mount_register_failed:${response.status}`);
+    }
+    if ('error' in payload) {
+        throw new Error(encodeMountConflictError({
+            ref: `${payload.creatorUsername}/${payload.appType}/${payload.appName}`,
+            ownerPid: payload.ownerPid,
+            repoRoot: payload.repoRoot,
+            htmlPath: payload.htmlPath,
+        }));
+    }
+    return {
+        mountId: payload.mountId,
+        appUrl: payload.appUrl,
+    };
+}
+async function heartbeatDevMount(mountId, ownerPid, port = exports.DEV_ROUTER_PORT) {
+    await fetchRouterJson(`${CONTROL_PREFIX}/mounts/${encodeURIComponent(mountId)}/heartbeat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ownerPid }),
+    }, port);
+}
+async function unregisterDevMount(mountId, port = exports.DEV_ROUTER_PORT) {
+    const response = await fetch(`http://${DEV_ROUTER_HOST}:${port}${CONTROL_PREFIX}/mounts/${encodeURIComponent(mountId)}`, {
+        method: 'DELETE',
+    });
+    if (!response.ok && response.status !== 404) {
+        throw new Error(`mount_unregister_failed:${response.status}`);
+    }
 }
 async function startDevServer(options) {
-    const { appName, htmlPath, port, projectInfo } = options;
+    const { appName, appType, creatorUsername, htmlPath, port, projectInfo } = options;
+    const ownerPid = process.pid;
     let closing = false;
     const devProcess = spawnDevScript(projectInfo);
+    if (devProcess) {
+        devProcess.on('exit', code => {
+            if (closing) {
+                return;
+            }
+            if (code !== 0 && code !== null) {
+                console.warn(`npm run dev exited with code ${code}.`);
+            }
+        });
+    }
     const startedDevProcess = Boolean(devProcess);
     const staticRoot = (0, node_path_1.resolve)((0, node_path_1.dirname)(htmlPath));
-    const server = node_http_1.default.createServer((req, res) => {
+    const repoRoot = (0, node_path_1.resolve)(projectInfo.projectDir ?? (0, node_path_1.dirname)(htmlPath));
+    let mountId = '';
+    let appUrl = '';
+    try {
+        await ensureDevRouterRunning(port);
+        const registeredMount = await registerDevMount({
+            creatorUsername,
+            appType,
+            appName,
+            htmlPath,
+            staticRoot,
+            repoRoot,
+            ownerPid,
+        }, port);
+        mountId = registeredMount.mountId;
+        appUrl = registeredMount.appUrl;
+    }
+    catch (error) {
+        if (devProcess && !devProcess.killed) {
+            devProcess.kill();
+        }
+        throw error;
+    }
+    const heartbeat = setInterval(() => {
+        heartbeatDevMount(mountId, ownerPid, port).catch(() => {
+            // Let the serving request fail naturally if the router disappears.
+        });
+    }, 2000);
+    return {
+        server: null,
+        devProcess,
+        startedDevProcess,
+        appUrl,
+        close: async () => {
+            if (closing)
+                return;
+            closing = true;
+            clearInterval(heartbeat);
+            try {
+                await unregisterDevMount(mountId, port);
+            }
+            finally {
+                if (devProcess && !devProcess.killed) {
+                    devProcess.kill();
+                }
+            }
+        },
+    };
+}
+async function isDevServerAvailable(input, timeoutMs = 1000) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    timeout.unref?.();
+    try {
+        await fetch(buildLocalDevAppUrl(input), {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function runDevRouterServer(port = Number(process.env.PLAYDROP_DEV_ROUTER_PORT) || exports.DEV_ROUTER_PORT) {
+    // eslint-disable-next-line complexity
+    const handleRequest = async (req, res) => {
         const method = req.method || 'GET';
-        // Enable CORS for development
         res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
         res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Playdrop-Client, X-Playdrop-Client-Version, X-Playdrop-Client-Build, X-Playdrop-Platform, X-Playdrop-Platform-Version');
         res.setHeader('Access-Control-Allow-Private-Network', 'true');
         if (method === 'OPTIONS') {
@@ -95,23 +369,134 @@ async function startDevServer(options) {
             res.end();
             return;
         }
+        let pathname = '/';
+        try {
+            pathname = decodeURIComponent(new URL(req.url || '/', `http://${DEV_ROUTER_HOST}:${port}`).pathname);
+        }
+        catch {
+            respondWithText(res, method, 400, 'Invalid URL path');
+            return;
+        }
+        if (pathname === `${CONTROL_PREFIX}/health` && method === 'GET') {
+            sendJson(res, 200, { status: 'ok' });
+            return;
+        }
+        if (pathname === `${CONTROL_PREFIX}/mounts` && method === 'POST') {
+            cleanupStaleRouterMounts();
+            const body = await readJsonBody(req);
+            const creatorUsername = body.creatorUsername?.trim();
+            const appType = body.appType?.trim();
+            const appName = body.appName?.trim();
+            const htmlPath = body.htmlPath?.trim();
+            const staticRoot = body.staticRoot?.trim();
+            const repoRoot = body.repoRoot?.trim();
+            const ownerPid = Number(body.ownerPid);
+            if (!creatorUsername || !appType || !appName || !htmlPath || !staticRoot || !repoRoot || !Number.isInteger(ownerPid) || ownerPid <= 0) {
+                sendJson(res, 400, { error: 'invalid_mount_request' });
+                return;
+            }
+            const key = buildMountKey(creatorUsername, appType, appName);
+            const existingMountId = routerMountIdsByKey.get(key);
+            if (existingMountId) {
+                const existingMount = routerMountsById.get(existingMountId);
+                if (existingMount && isPidAlive(existingMount.ownerPid)) {
+                    if (existingMount.htmlPath !== htmlPath || existingMount.staticRoot !== staticRoot) {
+                        sendJson(res, 409, {
+                            error: 'mount_conflict',
+                            creatorUsername,
+                            appType,
+                            appName,
+                            ownerPid: existingMount.ownerPid,
+                            repoRoot: existingMount.repoRoot,
+                            htmlPath: existingMount.htmlPath,
+                        });
+                        return;
+                    }
+                    existingMount.ownerPid = ownerPid;
+                    existingMount.updatedAt = Date.now();
+                    sendJson(res, 200, {
+                        mountId: existingMount.id,
+                        appUrl: buildLocalDevAppUrl({ creatorUsername, appType, appName, port }),
+                        creatorUsername,
+                        appType,
+                        appName,
+                    });
+                    return;
+                }
+                removeRouterMount(existingMountId);
+            }
+            const mount = {
+                id: (0, node_crypto_1.randomUUID)(),
+                key,
+                creatorUsername,
+                appType,
+                appName,
+                htmlPath,
+                staticRoot,
+                repoRoot,
+                ownerPid,
+                updatedAt: Date.now(),
+            };
+            routerMountsById.set(mount.id, mount);
+            routerMountIdsByKey.set(key, mount.id);
+            sendJson(res, 200, {
+                mountId: mount.id,
+                appUrl: buildLocalDevAppUrl({ creatorUsername, appType, appName, port }),
+                creatorUsername,
+                appType,
+                appName,
+            });
+            return;
+        }
+        if (pathname.startsWith(`${CONTROL_PREFIX}/mounts/`) && pathname.endsWith('/heartbeat') && method === 'POST') {
+            cleanupStaleRouterMounts();
+            const mountId = pathname.slice(`${CONTROL_PREFIX}/mounts/`.length, -'/heartbeat'.length).replace(/\/$/, '');
+            const mount = routerMountsById.get(mountId);
+            if (!mount) {
+                sendJson(res, 404, { error: 'mount_not_found' });
+                return;
+            }
+            const body = await readJsonBody(req);
+            const ownerPid = Number(body.ownerPid);
+            if (!Number.isInteger(ownerPid) || ownerPid <= 0) {
+                sendJson(res, 400, { error: 'invalid_mount_owner_pid' });
+                return;
+            }
+            if (ownerPid !== mount.ownerPid) {
+                sendJson(res, 409, { error: 'mount_owner_pid_mismatch' });
+                return;
+            }
+            mount.ownerPid = ownerPid;
+            mount.updatedAt = Date.now();
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        if (pathname.startsWith(`${CONTROL_PREFIX}/mounts/`) && method === 'DELETE') {
+            const mountId = pathname.slice(`${CONTROL_PREFIX}/mounts/`.length);
+            removeRouterMount(mountId);
+            sendJson(res, 200, { ok: true });
+            return;
+        }
         if (method !== 'GET' && method !== 'HEAD') {
-            res.setHeader('Allow', 'GET, HEAD, OPTIONS');
+            res.setHeader('Allow', 'GET, HEAD, POST, DELETE, OPTIONS');
             respondWithText(res, method, 405, 'Method not allowed');
             return;
         }
-        const url = new URL(req.url || '', `http://localhost:${port}`);
-        let pathname;
-        try {
-            pathname = decodeURIComponent(url.pathname);
+        cleanupStaleRouterMounts();
+        const parsedMountPath = parseMountPath(pathname);
+        if (!parsedMountPath) {
+            respondWithText(res, method, 404, 'Not found');
+            return;
         }
-        catch {
-            respondWithText(res, method, 400, 'Invalid URL path');
+        const mountId = routerMountIdsByKey.get(parsedMountPath.key);
+        const mount = mountId ? routerMountsById.get(mountId) : null;
+        if (!mount) {
+            respondWithText(res, method, 404, 'Not found');
             return;
         }
-        if (pathname === `/apps/${appName}.html` || pathname === `/${appName}.html`) {
+        if (parsedMountPath.assetPath === 'index.html') {
             try {
-                const freshHtml = (0, node_fs_1.readFileSync)(htmlPath);
+                const freshHtml = (0, node_fs_1.readFileSync)(mount.htmlPath);
                 respondWithBuffer(res, method, 200, 'text/html; charset=utf-8', freshHtml);
             }
             catch (error) {
@@ -119,12 +504,7 @@ async function startDevServer(options) {
             }
             return;
         }
-        if (!pathname.startsWith('/apps/')) {
-            respondWithText(res, method, 404, 'Not found');
-            return;
-        }
-        const relativePath = pathname.slice('/apps/'.length);
-        const absolutePath = resolveStaticPath(staticRoot, relativePath);
+        const absolutePath = resolveStaticPath(mount.staticRoot, parsedMountPath.assetPath);
         if (!absolutePath) {
             respondWithText(res, method, 400, 'Invalid static asset path');
             return;
@@ -141,61 +521,24 @@ async function startDevServer(options) {
         catch {
             respondWithText(res, method, 404, 'Not found');
         }
+    };
+    const server = node_http_1.default.createServer((req, res) => {
+        void handleRequest(req, res);
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolveListen, rejectListen) => {
         const onError = (error) => {
             server.off('listening', onListening);
-            reject(error);
+            rejectListen(error);
         };
         const onListening = () => {
             server.off('error', onError);
-            resolve();
+            resolveListen();
         };
         server.once('error', onError);
         server.once('listening', onListening);
-        server.listen(port);
+        server.listen(port, DEV_ROUTER_HOST);
+    });
+    await new Promise(() => {
+        // Keep the router alive until the process exits.
     });
-    const handle = {
-        server,
-        devProcess,
-        startedDevProcess,
-        appUrl: `http://localhost:${port}/apps/${appName}.html`,
-        close: async () => {
-            if (closing)
-                return;
-            closing = true;
-            await new Promise((resolveClose, rejectClose) => {
-                server.close(error => {
-                    if (error) {
-                        rejectClose(error);
-                    }
-                    else {
-                        resolveClose();
-                    }
-                });
-            });
-            if (devProcess && !devProcess.killed) {
-                devProcess.kill();
-            }
-        },
-    };
-    return handle;
-}
-async function isDevServerAvailable(appName, port, timeoutMs = 1000) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    timeout.unref?.();
-    try {
-        await fetch(`http://127.0.0.1:${port}/apps/${encodeURIComponent(appName)}.html`, {
-            method: 'GET',
-            signal: controller.signal,
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
 }

package/dist/commands/login.js

@@ -31,8 +31,16 @@ function storeLogin(env, data) {
         process.exitCode = 1;
         return;
     }
-    (0, config_1.saveConfig)({ token, env });
-    const username = data.user?.username ?? 'unknown';
+    const username = typeof data.user?.username === 'string' ? data.user.username.trim() : '';
+    if (!username) {
+        (0, messages_1.printErrorWithHelp)('Login succeeded but the account username was missing.', [
+            'Please try again in a moment.',
+            'If the issue persists, contact the Playdrop team.',
+        ], { command: 'login' });
+        process.exitCode = 1;
+        return;
+    }
+    (0, config_1.saveAccountSession)({ username, env, token });
     console.log(`Logged in as ${username} on ${env}.`);
     console.log('Next: run "playdrop auth whoami" to confirm your session.');
 }

package/dist/commands/logout.d.ts

@@ -1 +1,6 @@
-export declare function logout(): void;
+type LogoutOptions = {
+    username?: string;
+    env?: string;
+};
+export declare function logout(options?: LogoutOptions): void;
+export {};

package/dist/commands/logout.js

@@ -2,8 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logout = logout;
 const config_1 = require("../config");
-function logout() {
-    (0, config_1.clearConfig)();
-    console.log('Logged out.');
+function logout(options = {}) {
+    const current = (0, config_1.getCurrentAccountSession)();
+    const username = options.username?.trim() || current?.username || '';
+    const env = options.env?.trim() || current?.env || '';
+    const existingSession = username ? (0, config_1.findAccountSession)(username, env || undefined) : null;
+    if (!existingSession) {
+        if (username && env) {
+            console.log(`No stored session found for ${username} on ${env}.`);
+        }
+        else if (username) {
+            console.log(`No stored session found for ${username}.`);
+        }
+        else {
+            console.log('No stored session found.');
+        }
+        console.log('Next: run "playdrop auth login" when you need a new session.');
+        return;
+    }
+    (0, config_1.removeAccountSession)({ username, env });
+    if (username && env) {
+        console.log(`Logged out ${username} on ${env}.`);
+    }
+    else {
+        console.log('Logged out.');
+    }
     console.log('Next: run "playdrop auth login" when you need a new session.');
 }

package/dist/commands/search.d.ts

@@ -3,10 +3,15 @@ type SearchOptions = {
     appType?: string;
     assetCategory?: string;
     assetSubcategory?: string;
+    assetSpec?: string;
+    assetSpecOwner?: string;
+    assetSpecName?: string;
     packContainsCategory?: string;
     packContainsSubcategory?: string;
+    sort?: string;
     limit?: string | number;
     offset?: string | number;
+    tag?: string[];
     json?: boolean;
 };
 export declare function search(query: string | undefined, options?: SearchOptions): Promise<void>;