keystone-cli 2.0.0 → 2.1.0

package/src/utils/resource-loader.ts

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import * as path from 'node:path';
 import { join } from 'node:path';
 import { bundleAssets } from './assets.macro.ts' with { type: 'macro' };
 
@@ -129,30 +130,34 @@ export class ResourceLoader {
     return false;
   }
 
-  private static getProjectRelativePath(path: string): string | null {
+  /**
+   * Returns the manifest of embedded assets.
+   */
+  static getEmbeddedAssets(): Record<string, string> {
+    return { ...EMBEDDED_ASSETS };
+  }
+
+  private static getProjectRelativePath(targetPath: string): string | null {
     const cwd = process.cwd();
     const keystoneDir = join(cwd, '.keystone');
 
-    if (path.startsWith(keystoneDir)) {
-      return path.slice(keystoneDir.length + 1);
-    }
-
-    // If it's already relative and starts with .keystone
-    if (path.startsWith('.keystone/')) {
-      return path.slice(10);
-    }
-
-    if (path === '.keystone') {
-      return '';
+    // Use path.resolve to handle potential .. and normalization
+    const absTarget = join(cwd, targetPath); // assume relative to cwd if not absolute, checking resolve
+    // Actually, join/resolve logic:
+    // If targetPath is absolute, resolve returns it. If relative, joins with cwd.
+    const resolvedTarget = path.resolve(targetPath);
+    const resolvedKeystone = path.resolve(keystoneDir);
+
+    // Check if target is inside keystone dir
+    // We use relative() to check containment
+    const rel = path.relative(resolvedKeystone, resolvedTarget);
+
+    // If rel starts with '..', it is outside. If strictly inside, it won't start with ..
+    // Also internal paths shouldn't be absolute (on windows relative might return absolute if different drive)
+    if (!rel.startsWith('..') && !path.isAbsolute(rel)) {
+      return rel;
     }
 
     return null;
   }
-
-  /**
-   * Get all embedded assets for debugging/manifest
-   */
-  static getEmbeddedAssets(): Record<string, string> {
-    return EMBEDDED_ASSETS;
-  }
 }

package/src/utils/sandbox.ts

@@ -109,6 +109,12 @@ export class SafeSandbox {
     options: SandboxOptions = {}
   ): Promise<unknown> {
     // Show warning once per process
+    if (process.env.NODE_ENV === 'production') {
+      throw new Error(
+        'Security Error: Insecure VM fallback is disabled in production environment. Use process isolation.'
+      );
+    }
+
     if (!SafeSandbox.warned) {
       SafeSandbox.logger.warn(
         '\n⚠️  SECURITY WARNING: Using Bun/Node.js built-in VM for script execution.\n' +

package/src/utils/stream-utils.ts

@@ -0,0 +1,58 @@
+import { StringDecoder } from 'node:string_decoder';
+
+export const TRUNCATED_SUFFIX = '\n... [truncated]';
+
+export interface OutputLimiter {
+  append(chunk: Buffer | string): void;
+  finalize(): string;
+  readonly truncated: boolean;
+}
+
+/**
+ * Creates a limiter that accumulates output up to a maximum number of bytes.
+ * Handles multi-byte character boundaries correctly using StringDecoder.
+ */
+export function createOutputLimiter(maxBytes: number): OutputLimiter {
+  let bytes = 0;
+  let text = '';
+  let truncated = false;
+  // Use StringDecoder to correctly handle multi-byte characters split across chunks
+  const decoder = new StringDecoder('utf8');
+
+  const append = (chunk: Buffer | string) => {
+    if (truncated || maxBytes <= 0) {
+      truncated = true;
+      return;
+    }
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const remaining = maxBytes - bytes;
+    if (remaining <= 0) {
+      truncated = true;
+      return;
+    }
+    if (buffer.length <= remaining) {
+      text += decoder.write(buffer);
+      bytes += buffer.length;
+      return;
+    }
+    // Truncate logic: decode up to allowable bytes
+    const sub = buffer.subarray(0, remaining);
+    text += decoder.write(sub);
+    bytes = maxBytes;
+    truncated = true;
+  };
+
+  const finalize = () => {
+    // Flush any remaining bytes in the decoder
+    text += decoder.end();
+    return truncated ? `${text}${TRUNCATED_SUFFIX}` : text;
+  };
+
+  return {
+    append,
+    finalize,
+    get truncated() {
+      return truncated;
+    },
+  };
+}