uloop-cli 0.68.2 → 0.69.0

package/src/project-validator.ts

@@ -0,0 +1,70 @@
+/**
+ * Project validation for CLI.
+ * Verifies that the connected Unity instance belongs to the expected project.
+ */
+
+// Paths come from trusted Unity responses and validated project root, console.error for user warnings
+/* eslint-disable security/detect-non-literal-fs-filename, no-console */
+
+import assert from 'node:assert';
+import { realpath } from 'fs/promises';
+import { dirname } from 'path';
+import { DirectUnityClient } from './direct-unity-client.js';
+
+export class ProjectMismatchError extends Error {
+  constructor(
+    public readonly expectedProjectRoot: string,
+    public readonly connectedProjectRoot: string,
+  ) {
+    super('PROJECT_MISMATCH');
+  }
+}
+
+interface GetVersionResponse {
+  DataPath: string;
+}
+
+const JSON_RPC_METHOD_NOT_FOUND = -32601;
+
+async function normalizePath(path: string): Promise<string> {
+  const resolved = await realpath(path);
+  return resolved.replace(/\/+$/, '');
+}
+
+export async function validateConnectedProject(
+  client: DirectUnityClient,
+  expectedProjectRoot: string,
+): Promise<void> {
+  assert(client.isConnected(), 'client must be connected before validation');
+
+  let response: GetVersionResponse;
+  try {
+    response = await client.sendRequest<GetVersionResponse>('get-version', {});
+  } catch (error) {
+    // Method not found: old uLoopMCP version without get-version tool
+    if (
+      error instanceof Error &&
+      (error.message.includes(`${JSON_RPC_METHOD_NOT_FOUND}`) ||
+        /method not found/i.test(error.message))
+    ) {
+      console.error(
+        'Warning: Could not verify project identity (get-version not available). Consider updating uLoopMCP package.',
+      );
+      return;
+    }
+    throw error;
+  }
+
+  if (typeof response?.DataPath !== 'string' || response.DataPath.length === 0) {
+    console.error('Warning: Could not verify project identity (invalid get-version response).');
+    return;
+  }
+
+  const connectedProjectRoot = dirname(response.DataPath);
+  const normalizedExpected = await normalizePath(expectedProjectRoot);
+  const normalizedConnected = await normalizePath(connectedProjectRoot);
+
+  if (normalizedExpected !== normalizedConnected) {
+    throw new ProjectMismatchError(normalizedExpected, normalizedConnected);
+  }
+}

package/src/simple-framer.ts

@@ -11,7 +11,7 @@ export function createFrame(jsonContent: string): string {
   return `${CONTENT_LENGTH_HEADER} ${contentLength}${HEADER_SEPARATOR}${jsonContent}`;
 }
 
-export interface FrameParseResult {
+interface FrameParseResult {
   contentLength: number;
   headerLength: number;
   isComplete: boolean;
@@ -43,7 +43,7 @@ export function parseFrameFromBuffer(data: Buffer): FrameParseResult {
   return { contentLength, headerLength, isComplete };
 }
 
-export interface FrameExtractionResult {
+interface FrameExtractionResult {
   jsonContent: string | null;
   remainingData: Buffer;
 }

package/src/skills/deprecated-skills.ts

@@ -6,5 +6,5 @@
  */
 export const DEPRECATED_SKILLS: string[] = [
   'uloop-capture-window', // renamed to uloop-screenshot in v0.54.0
-  'uloop-get-provider-details', // internal development-only tool, not for end users
+  'uloop-get-provider-details', // renamed to uloop-get-unity-search-providers
 ];

package/src/skills/skills-manager.ts

@@ -15,16 +15,16 @@ import { findUnityProjectRoot, getUnityProjectStatus } from '../project-root.js'
 import { DEPRECATED_SKILLS } from './deprecated-skills.js';
 import { loadDisabledTools } from '../tool-settings-loader.js';
 
-export type SkillStatus = 'installed' | 'not_installed' | 'outdated';
+type SkillStatus = 'installed' | 'not_installed' | 'outdated';
 
-export interface SkillInfo {
+interface SkillInfo {
   name: string;
   status: SkillStatus;
   path?: string;
   source?: 'bundled' | 'project';
 }
 
-export interface SkillDefinition {
+interface SkillDefinition {
   name: string;
   toolName?: string;
   dirName: string;
@@ -132,7 +132,7 @@ function isSkillOutdated(skill: SkillDefinition, target: TargetConfig, global: b
   return false;
 }
 
-export function getSkillStatus(
+function getSkillStatus(
   skill: SkillDefinition,
   target: TargetConfig,
   global: boolean,
@@ -290,7 +290,7 @@ function findEditorFolders(basePath: string, maxDepth: number = 2): string[] {
   return editorFolders;
 }
 
-export function collectProjectSkills(excludedRoots: string[] = []): SkillDefinition[] {
+function collectProjectSkills(excludedRoots: string[] = []): SkillDefinition[] {
   const projectRoot = findUnityProjectRoot();
   if (!projectRoot) {
     return [];
@@ -342,7 +342,7 @@ export function getAllSkillStatuses(target: TargetConfig, global: boolean): Skil
   }));
 }
 
-export function installSkill(skill: SkillDefinition, target: TargetConfig, global: boolean): void {
+function installSkill(skill: SkillDefinition, target: TargetConfig, global: boolean): void {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   const skillDir = join(baseDir, skill.dirName);
   const skillPath = join(skillDir, target.skillFileName);
@@ -360,11 +360,7 @@ export function installSkill(skill: SkillDefinition, target: TargetConfig, globa
   }
 }
 
-export function uninstallSkill(
-  skill: SkillDefinition,
-  target: TargetConfig,
-  global: boolean,
-): boolean {
+function uninstallSkill(skill: SkillDefinition, target: TargetConfig, global: boolean): boolean {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   const skillDir = join(baseDir, skill.dirName);
 
@@ -376,7 +372,7 @@ export function uninstallSkill(
   return true;
 }
 
-export interface InstallResult {
+interface InstallResult {
   installed: number;
   updated: number;
   skipped: number;
@@ -448,7 +444,7 @@ function isSkillDisabledByToolSettings(skill: SkillDefinition, disabledTools: st
   return disabledTools.includes(toolName);
 }
 
-export interface UninstallResult {
+interface UninstallResult {
   removed: number;
   notFound: number;
 }

package/src/skills/target-config.ts

@@ -12,7 +12,7 @@ export interface TargetConfig {
   skillFileName: string;
 }
 
-export const TARGET_CONFIGS: Record<TargetId, TargetConfig> = {
+const TARGET_CONFIGS: Record<TargetId, TargetConfig> = {
   claude: {
     id: 'claude',
     displayName: 'Claude Code',

package/src/spinner.ts

@@ -8,7 +8,7 @@
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'] as const;
 const FRAME_INTERVAL_MS = 80;
 
-export interface Spinner {
+interface Spinner {
   update(message: string): void;
   stop(): void;
 }

package/src/tool-cache.ts

@@ -41,7 +41,10 @@ export interface ToolsCache {
 const CACHE_DIR = '.uloop';
 const CACHE_FILE = 'tools.json';
 
-function getCacheDir(): string {
+function getCacheDir(projectPath?: string): string {
+  if (projectPath !== undefined) {
+    return join(projectPath, CACHE_DIR);
+  }
   const projectRoot = findUnityProjectRoot();
   if (projectRoot === null) {
     return join(process.cwd(), CACHE_DIR);
@@ -49,8 +52,8 @@ function getCacheDir(): string {
   return join(projectRoot, CACHE_DIR);
 }
 
-function getCachePath(): string {
-  return join(getCacheDir(), CACHE_FILE);
+function getCachePath(projectPath?: string): string {
+  return join(getCacheDir(projectPath), CACHE_FILE);
 }
 
 /**
@@ -62,9 +65,10 @@ export function getDefaultTools(): ToolsCache {
 
 /**
  * Load tools from cache file, falling back to default tools if cache doesn't exist.
+ * When projectPath is specified, reads cache from that project directory.
  */
-export function loadToolsCache(): ToolsCache {
-  const cachePath = getCachePath();
+export function loadToolsCache(projectPath?: string): ToolsCache {
+  const cachePath = getCachePath(projectPath);
 
   if (existsSync(cachePath)) {
     try {
@@ -107,6 +111,15 @@ export function getCacheFilePath(): string {
   return getCachePath();
 }
 
+/**
+ * Get the set of default tool names bundled with npm package.
+ * Used to distinguish built-in tools from third-party tools.
+ */
+export function getDefaultToolNames(): ReadonlySet<string> {
+  const defaultTools: ToolsCache = getDefaultTools();
+  return new Set(defaultTools.tools.map((tool: ToolDefinition) => tool.name));
+}
+
 /**
  * Get the Unity server version from cache file.
  * Returns undefined if cache doesn't exist, is corrupted, or serverVersion is missing.

package/src/version.ts

@@ -4,4 +4,4 @@
  * This file exists to avoid bundling the entire package.json into the CLI bundle.
  * This version is automatically updated by release-please.
  */
-export const VERSION = '0.68.2'; // x-release-please-version
+export const VERSION = '0.69.0'; // x-release-please-version