@unibridge/sdk 0.5.0 → 0.9.0

package/src/hash.test.ts

@@ -1,48 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { pipePath, projectHash, stateDir } from './hash.ts'
-
-describe('projectHash', () => {
-  it('returns a 12-char hex string', () => {
-    const hash = projectHash('/Users/me/MyGame')
-    assert.equal(hash.length, 12)
-    assert.match(hash, /^[a-f0-9]{12}$/)
-  })
-
-  it('is deterministic', () => {
-    const a = projectHash('/Users/me/MyGame')
-    const b = projectHash('/Users/me/MyGame')
-    assert.equal(a, b)
-  })
-
-  it('differs for different paths', () => {
-    const a = projectHash('/Users/me/GameA')
-    const b = projectHash('/Users/me/GameB')
-    assert.notEqual(a, b)
-  })
-
-  it('normalizes trailing slash differences', () => {
-    const a = projectHash('/Users/me/MyGame')
-    const b = projectHash('/Users/me/MyGame/')
-    assert.equal(a, b)
-  })
-
-  it('handles paths with spaces', () => {
-    const hash = projectHash('/Users/me/My Game')
-    assert.match(hash, /^[a-f0-9]{12}$/)
-  })
-})
-
-describe('pipePath', () => {
-  it('returns a unix socket path on non-Windows', () => {
-    const path = pipePath('/Users/me/MyGame')
-    assert.match(path, /^\/tmp\/unibridge\/[a-f0-9]{12}\/bridge\.sock$/)
-  })
-})
-
-describe('stateDir', () => {
-  it('returns the temp directory for the project', () => {
-    const dir = stateDir('/Users/me/MyGame')
-    assert.match(dir, /^\/tmp\/unibridge\/[a-f0-9]{12}$/)
-  })
-})

package/src/hash.ts

@@ -1,50 +0,0 @@
-import { createHash } from 'node:crypto'
-import { realpathSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-
-function canonicalizeProjectPath(projectPath: string): string {
-  const resolved = path.resolve(projectPath)
-  let canonical = resolved
-
-  try {
-    canonical = realpathSync.native(resolved)
-  } catch {
-    // Fall back to the resolved path when it does not exist yet.
-  }
-
-  canonical = canonical.replace(/\\/g, '/')
-  canonical = canonical.replace(/\/+$/g, '')
-
-  if (process.platform === 'win32') {
-    canonical = canonical.toLowerCase()
-  }
-
-  return canonical
-}
-
-export function projectHash(projectPath: string): string {
-  const canonical = canonicalizeProjectPath(projectPath)
-  return createHash('sha256').update(canonical).digest('hex').slice(0, 12)
-}
-
-function stateBaseDir(): string {
-  if (process.platform === 'win32') {
-    return path.join(os.tmpdir(), 'unibridge')
-  }
-
-  return '/tmp/unibridge'
-}
-
-export function stateDir(projectPath: string): string {
-  return path.join(stateBaseDir(), projectHash(projectPath))
-}
-
-export function pipePath(projectPath: string): string {
-  const hash = projectHash(projectPath)
-  if (process.platform === 'win32') {
-    return `\\\\.\\pipe\\unibridge-${hash}`
-  }
-
-  return path.join(stateBaseDir(), hash, 'bridge.sock')
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export { init, findUnityProject, isPluginInstalled } from './project.ts'
-export { createClient } from './client.ts'
-export type * from './commands/contracts.ts'
-export type {
-  InitOptions,
-  InitResult,
-  CommandResponse,
-  ClientOptions,
-  UniBridgeClient,
-} from './types.ts'

package/src/project.test.ts

@@ -1,93 +0,0 @@
-import { afterEach, beforeEach, describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { findUnityProject, init, isPluginInstalled, parseUnityVersion } from './project.ts'
-
-const baseDir = '/tmp/unibridge-sdk-project-tests'
-const testDir = `${baseDir}/test-unity-project`
-const testDirWithSpaces = `${baseDir}/test unity project`
-
-function createFakeProject(path: string, version = '2022.3.10f1') {
-  mkdirSync(`${path}/Assets`, { recursive: true })
-  mkdirSync(`${path}/ProjectSettings`, { recursive: true })
-  mkdirSync(`${path}/Packages`, { recursive: true })
-  writeFileSync(`${path}/ProjectSettings/ProjectVersion.txt`, `m_EditorVersion: ${version}\n`)
-  writeFileSync(`${path}/Packages/manifest.json`, JSON.stringify({ dependencies: {} }, null, 2))
-}
-
-describe('findUnityProject', () => {
-  beforeEach(() => createFakeProject(testDir))
-  afterEach(() => rmSync(baseDir, { recursive: true, force: true }))
-
-  it('finds project at the given path', () => {
-    assert.equal(findUnityProject(testDir), testDir)
-  })
-
-  it('finds project from a subdirectory', () => {
-    mkdirSync(`${testDir}/Assets/Scripts`, { recursive: true })
-    assert.equal(findUnityProject(`${testDir}/Assets/Scripts`), testDir)
-  })
-
-  it('supports project paths with spaces', () => {
-    createFakeProject(testDirWithSpaces)
-    assert.equal(findUnityProject(testDirWithSpaces), testDirWithSpaces)
-  })
-
-  it('throws when no Unity project is found', () => {
-    assert.throws(() => findUnityProject('/tmp'), /Unity project not found/)
-  })
-})
-
-describe('parseUnityVersion', () => {
-  beforeEach(() => createFakeProject(testDir, '6000.0.23f1'))
-  afterEach(() => rmSync(baseDir, { recursive: true, force: true }))
-
-  it('extracts version string', () => {
-    assert.equal(parseUnityVersion(testDir), '6000.0.23f1')
-  })
-})
-
-describe('init', () => {
-  beforeEach(() => createFakeProject(testDir))
-  afterEach(() => rmSync(baseDir, { recursive: true, force: true }))
-
-  it('adds plugin to manifest.json with git source', async () => {
-    const result = await init({ projectPath: testDir })
-    assert.equal(result.unityVersion, '2022.3.10f1')
-    assert.equal(result.pluginSource, 'git')
-
-    const manifest = JSON.parse(readFileSync(`${testDir}/Packages/manifest.json`, 'utf-8'))
-    assert.ok(manifest.dependencies['com.msanatan.unibridge'])
-  })
-
-  it('adds plugin with local source', async () => {
-    const result = await init({
-      projectPath: testDir,
-      source: { type: 'local', path: '../unibridge/unity' },
-    })
-    assert.equal(result.pluginSource, 'local')
-
-    const manifest = JSON.parse(readFileSync(`${testDir}/Packages/manifest.json`, 'utf-8'))
-    assert.equal(manifest.dependencies['com.msanatan.unibridge'], 'file:../unibridge/unity')
-  })
-
-  it('no-ops when plugin is already at correct version', async () => {
-    await init({ projectPath: testDir })
-    const result = await init({ projectPath: testDir })
-    assert.equal(result.pluginSource, 'git')
-  })
-})
-
-describe('isPluginInstalled', () => {
-  beforeEach(() => createFakeProject(testDir))
-  afterEach(() => rmSync(baseDir, { recursive: true, force: true }))
-
-  it('returns false when dependency is absent', () => {
-    assert.equal(isPluginInstalled(testDir), false)
-  })
-
-  it('returns true after init installs the plugin', async () => {
-    await init({ projectPath: testDir })
-    assert.equal(isPluginInstalled(testDir), true)
-  })
-})

package/src/project.ts

@@ -1,99 +0,0 @@
-import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
-import path from 'node:path'
-import { cwd } from 'node:process'
-import type { InitOptions, InitResult } from './types.ts'
-
-const PLUGIN_NAME = 'com.msanatan.unibridge'
-
-const SDK_VERSION = (
-  JSON.parse(
-    readFileSync(path.join(import.meta.dirname, '..', 'package.json'), 'utf-8'),
-  ) as { version: string }
-).version
-
-const DEFAULT_GIT_SOURCE =
-  `https://github.com/msanatan/unibridge.git?path=unity#v${SDK_VERSION}`
-
-interface Manifest {
-  dependencies?: Record<string, string>
-}
-
-function readManifest(projectPath: string): Manifest {
-  const manifestPath = path.join(projectPath, 'Packages', 'manifest.json')
-  return JSON.parse(readFileSync(manifestPath, 'utf-8')) as Manifest
-}
-
-function writeManifestAtomic(projectPath: string, manifest: Manifest): void {
-  const manifestPath = path.join(projectPath, 'Packages', 'manifest.json')
-  const tempPath = `${manifestPath}.tmp`
-  const content = `${JSON.stringify(manifest, null, 2)}\n`
-  writeFileSync(tempPath, content, 'utf-8')
-  renameSync(tempPath, manifestPath)
-}
-
-export function findUnityProject(startPath: string = cwd()): string {
-  let current = path.resolve(startPath)
-
-  while (true) {
-    const assetsPath = path.join(current, 'Assets')
-    const versionPath = path.join(current, 'ProjectSettings', 'ProjectVersion.txt')
-
-    if (existsSync(assetsPath) && existsSync(versionPath)) {
-      return current
-    }
-
-    const parent = path.dirname(current)
-    if (parent === current) {
-      throw new Error('Unity project not found. Run inside a Unity project or pass --project <path>.')
-    }
-
-    current = parent
-  }
-}
-
-export function parseUnityVersion(projectPath: string): string {
-  const versionPath = path.join(projectPath, 'ProjectSettings', 'ProjectVersion.txt')
-  const content = readFileSync(versionPath, 'utf-8')
-  const match = content.match(/m_EditorVersion:\s*(\S+)/)
-  if (!match) {
-    throw new Error(`Could not parse m_EditorVersion from ${versionPath}`)
-  }
-
-  return match[1]
-}
-
-export function isPluginInstalled(projectPath: string): boolean {
-  const manifest = readManifest(projectPath)
-  return Boolean(manifest.dependencies?.[PLUGIN_NAME])
-}
-
-export async function init(options: InitOptions = {}): Promise<InitResult> {
-  const projectPath = findUnityProject(options.projectPath)
-  const unityVersion = parseUnityVersion(projectPath)
-
-  const manifest = readManifest(projectPath)
-  const dependencies = { ...(manifest.dependencies ?? {}) }
-
-  const pluginSource = options.source?.type ?? 'git'
-  const pluginReference =
-    options.source?.type === 'local'
-      ? `file:${options.source.path}`
-      : options.source?.type === 'git'
-        ? options.source.url
-        : DEFAULT_GIT_SOURCE
-
-  if (dependencies[PLUGIN_NAME] !== pluginReference) {
-    dependencies[PLUGIN_NAME] = pluginReference
-    writeManifestAtomic(projectPath, {
-      ...manifest,
-      dependencies,
-    })
-  }
-
-  return {
-    projectPath,
-    unityVersion,
-    pluginVersion: SDK_VERSION,
-    pluginSource,
-  }
-}

package/src/types.ts

@@ -1,64 +0,0 @@
-import type { CommandMethods } from './commands/define.ts'
-import type { allCommands } from './commands/registry.ts'
-
-export interface InitOptions {
-  projectPath?: string
-  source?: GitSource | LocalSource
-}
-
-export interface GitSource {
-  type: 'git'
-  url: string
-}
-
-export interface LocalSource {
-  type: 'local'
-  path: string
-}
-
-export interface InitResult {
-  projectPath: string
-  unityVersion: string
-  pluginVersion: string
-  pluginSource: 'git' | 'local'
-}
-
-export interface CommandRequest {
-  id: string
-  command: string
-  params: Record<string, unknown>
-}
-
-export interface CommandResponse {
-  id: string
-  success: boolean
-  result?: unknown
-  error?: string
-}
-
-export interface ServerMetadata {
-  pid: number
-  unityVersion: string
-  pluginVersion: string
-  protocolVersion: number
-  capabilities?: {
-    executeEnabled?: boolean
-  }
-  projectPath?: string
-}
-
-export interface TimeoutOptions {
-  connectTimeout?: number
-  commandTimeout?: number
-  reconnectTimeout?: number
-}
-
-export interface ClientOptions extends TimeoutOptions {
-  projectPath?: string
-  enableExecute?: boolean
-}
-
-export type UniBridgeClient = CommandMethods<typeof allCommands> & {
-  readonly projectPath: string
-  close(): void
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "src/**/*.test.ts"
-  ]
-}