@unibridge/cli 0.5.0 → 0.8.0

package/src/commands/with-unity-client.ts

@@ -1,47 +0,0 @@
-import type { Command } from 'commander'
-import { createClient } from '@unibridge/sdk'
-import { getGlobalOptions } from '../options.ts'
-import { resolveCommandProject } from '../preflight.ts'
-
-interface ClientCommandRequirements {
-  requirePlugin: boolean
-  requiresExecute?: boolean
-}
-
-interface GlobalCommandContext {
-  jsonOutput: boolean
-}
-
-export async function withUnityClient(
-  command: Command,
-  requirements: ClientCommandRequirements,
-  run: (client: ReturnType<typeof createClient>, ctx: GlobalCommandContext) => Promise<void>,
-): Promise<void> {
-  let client: ReturnType<typeof createClient> | undefined
-
-  try {
-    const globalOpts = getGlobalOptions(command)
-    const envExecute = process.env.UNIBRIDGE_ENABLE_EXECUTE !== '0'
-    const executeEnabled = globalOpts.execute !== false && envExecute
-
-    const projectPath = resolveCommandProject(
-      {
-        project: globalOpts.project,
-        execute: executeEnabled,
-      },
-      requirements,
-    )
-
-    client = createClient({
-      projectPath,
-      enableExecute: executeEnabled,
-      connectTimeout: 10_000,
-    })
-
-    await run(client, {
-      jsonOutput: globalOpts.json === true,
-    })
-  } finally {
-    client?.close()
-  }
-}

package/src/index.ts

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-import { readFileSync } from 'node:fs'
-import path from 'node:path'
-import { program } from 'commander'
-import { registerDomain } from './commands/domain.ts'
-import { registerInit } from './commands/init.ts'
-import { registerExecute } from './commands/execute.ts'
-import { registerStatus } from './commands/status.ts'
-import { registerScene } from './commands/scene.ts'
-
-const { version } = JSON.parse(
-  readFileSync(path.join(import.meta.dirname, '..', 'package.json'), 'utf-8'),
-) as { version: string }
-
-program
-  .name('unibridge')
-  .description('Bridge between Unity and your code')
-  .version(version)
-  .option('-p, --project <path>', 'Path to Unity project')
-  .option('--json', 'Output result as JSON')
-  .option('--no-execute', 'Disable execute tool for this invocation')
-
-registerDomain(program)
-registerInit(program)
-registerExecute(program)
-registerStatus(program)
-registerScene(program)
-
-program.parse()

package/src/options.ts

@@ -1,11 +0,0 @@
-import type { Command } from 'commander'
-
-export interface GlobalCommandOptions {
-  project?: string
-  json?: boolean
-  execute?: boolean
-}
-
-export function getGlobalOptions(command: Command): GlobalCommandOptions {
-  return command.optsWithGlobals() as GlobalCommandOptions
-}

package/src/preflight.test.ts

@@ -1,39 +0,0 @@
-import { afterEach, beforeEach, describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
-import { resolveCommandProject } from './preflight.ts'
-
-const projectPath = '/tmp/unibridge-cli-preflight/My Game'
-
-beforeEach(() => {
-  mkdirSync(`${projectPath}/Assets`, { recursive: true })
-  mkdirSync(`${projectPath}/ProjectSettings`, { recursive: true })
-  mkdirSync(`${projectPath}/Packages`, { recursive: true })
-  writeFileSync(`${projectPath}/ProjectSettings/ProjectVersion.txt`, 'm_EditorVersion: 2022.3.10f1\n')
-  writeFileSync(`${projectPath}/Packages/manifest.json`, JSON.stringify({ dependencies: {} }, null, 2))
-})
-
-afterEach(() => {
-  rmSync('/tmp/unibridge-cli-preflight', { recursive: true, force: true })
-})
-
-describe('resolveCommandProject', () => {
-  it('throws when plugin is missing for command execution', () => {
-    assert.throws(
-      () => resolveCommandProject({ project: projectPath, execute: true }, { requirePlugin: true, requiresExecute: true }),
-      /Run `unibridge init` first/,
-    )
-  })
-
-  it('throws when execute is disabled', () => {
-    writeFileSync(
-      `${projectPath}/Packages/manifest.json`,
-      JSON.stringify({ dependencies: { 'com.msanatan.unibridge': 'file:../unity' } }, null, 2),
-    )
-
-    assert.throws(
-      () => resolveCommandProject({ project: projectPath, execute: false }, { requirePlugin: true, requiresExecute: true }),
-      /Execute is disabled/,
-    )
-  })
-})

package/src/preflight.ts

@@ -1,23 +0,0 @@
-import { findUnityProject, isPluginInstalled } from '@unibridge/sdk'
-
-export function resolveCommandProject(
-  opts: { project?: string; execute?: boolean },
-  config: { requirePlugin: boolean; requiresExecute?: boolean },
-): string {
-  let projectPath: string
-  try {
-    projectPath = findUnityProject(opts.project)
-  } catch {
-    throw new Error('Unity project not found. Run inside a Unity project or pass --project <path>.')
-  }
-
-  if (config.requiresExecute && opts.execute === false) {
-    throw new Error('Execute is disabled for this invocation (--no-execute).')
-  }
-
-  if (config.requirePlugin && !isPluginInstalled(projectPath)) {
-    throw new Error('com.msanatan.unibridge is not installed. Run `unibridge init` first.')
-  }
-
-  return projectPath
-}

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"
-  ]
-}