@playcraft/cli 0.1.28 → 0.1.30

package/dist/workspace-runtime/workspaces/files-search.js

@@ -0,0 +1,116 @@
+import { createHash } from 'node:crypto';
+import { lstat, opendir, realpath } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+import { workspaceFileSearchQuerySchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+const SKIP_DIRECTORIES = new Set(['.git', 'node_modules', '.playcraft', '.next', 'dist', 'build', 'coverage', '.turbo']);
+const SCAN_PAGE_ENTRIES = 1000;
+export class InvalidWorkspaceSearchError extends Error {
+    code;
+    constructor(code = 'invalid_workspace_search') {
+        super(code);
+        this.code = code;
+        this.name = 'InvalidWorkspaceSearchError';
+    }
+}
+/** Enumerates names only. The cursor is scoped to the resolved checkout and query, never to a caller supplied path. */
+export async function searchWorkspaceFiles(root, query, options = {}) {
+    const parsed = workspaceFileSearchQuerySchema.safeParse(query);
+    if (!parsed.success)
+        throw new InvalidWorkspaceSearchError();
+    options.signal?.throwIfAborted();
+    const rootReal = await realpath(root);
+    const needle = parsed.data.query.toLocaleLowerCase();
+    const scope = createHash('sha256').update(rootReal).update('\0').update(needle).digest('hex');
+    const start = decodeCursor(parsed.data.cursor, scope);
+    const files = [];
+    let offset = 0;
+    for await (const path of walk(rootReal, rootReal, options.signal)) {
+        options.signal?.throwIfAborted();
+        offset += 1;
+        if (offset <= start)
+            continue;
+        if (path && path.toLocaleLowerCase().includes(needle)) {
+            const target = join(rootReal, ...path.split('/'));
+            const info = await lstat(target).catch(ignoreUnavailable);
+            const targetReal = info?.isFile() && !info.isSymbolicLink() ? await realpath(target).catch(ignoreUnavailable) : undefined;
+            if (targetReal && inside(rootReal, targetReal))
+                files.push({ path });
+        }
+        if (files.length >= parsed.data.limit || offset - start >= SCAN_PAGE_ENTRIES) {
+            return { files, truncated: true, nextCursor: encodeCursor(scope, offset) };
+        }
+    }
+    return { files, truncated: false };
+}
+async function* walk(root, current, signal) {
+    signal?.throwIfAborted();
+    const currentInfo = await lstat(current).catch(ignoreUnavailable);
+    if (!currentInfo?.isDirectory() || currentInfo.isSymbolicLink())
+        return;
+    const resolved = await realpath(current).catch(ignoreUnavailable);
+    if (!resolved || !inside(root, resolved))
+        return;
+    const directory = await opendir(resolved).catch(ignoreUnavailable);
+    if (!directory)
+        return;
+    // Recheck after opening: a concurrently replaced directory must not reveal another checkout's paths.
+    const openedPath = await realpath(current).catch(ignoreUnavailable);
+    if (openedPath !== resolved || !inside(root, openedPath)) {
+        await directory.close();
+        return;
+    }
+    for await (const entry of directory) {
+        signal?.throwIfAborted();
+        if (['.git', 'node_modules', '.playcraft'].includes(entry.name)) {
+            yield undefined;
+            continue;
+        }
+        const child = join(resolved, entry.name);
+        const path = relative(root, child).split(sep).join('/');
+        if (!workspaceRelativePathSchema.safeParse(path).success) {
+            yield undefined;
+            continue;
+        }
+        if (entry.isDirectory()) {
+            yield undefined;
+            if (!SKIP_DIRECTORIES.has(entry.name))
+                yield* walk(root, child, signal);
+            continue;
+        }
+        if (!entry.isFile()) {
+            yield undefined;
+            continue;
+        }
+        yield path;
+    }
+}
+function inside(root, path) {
+    const value = relative(root, path);
+    return value === '' || (value !== '..' && !value.startsWith(`..${sep}`) && !value.startsWith(sep));
+}
+function ignoreUnavailable(error) {
+    if (['ENOENT', 'ENOTDIR', 'EACCES'].includes(error.code ?? ''))
+        return undefined;
+    throw error;
+}
+function encodeCursor(scope, offset) {
+    return Buffer.from(JSON.stringify({ v: 1, scope, offset })).toString('base64url');
+}
+function decodeCursor(cursor, scope) {
+    if (!cursor)
+        return 0;
+    try {
+        if (!/^[A-Za-z0-9_-]+$/.test(cursor))
+            throw new Error();
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (typeof value !== 'object' || value === null)
+            throw new Error();
+        const { v, scope: suppliedScope, offset } = value;
+        if (v !== 1 || suppliedScope !== scope || typeof offset !== 'number' || !Number.isSafeInteger(offset) || offset < 0)
+            throw new Error();
+        return offset;
+    }
+    catch {
+        throw new InvalidWorkspaceSearchError('invalid_workspace_search_cursor');
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "private": false,
   "type": "module",
   "engines": {
@@ -50,8 +50,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.1.28",
-    "@playcraft/common": "^0.1.28",
+    "@playcraft/build": "^0.1.30",
+    "@playcraft/common": "^0.1.30",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",