@xincli/opentui-core 0.4.6

package/scripts/dist-test.ts

@@ -0,0 +1,312 @@
+import { spawnSync, type SpawnSyncReturns } from "node:child_process"
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { dirname, join, relative, resolve } from "node:path"
+import process from "node:process"
+import { fileURLToPath } from "node:url"
+
+import { requireNode26 } from "../../../scripts/node26.mjs"
+
+interface PackageJson {
+  name: string
+  version: string
+}
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const rootDir = resolve(__dirname, "..")
+const distDir = join(rootDir, "dist")
+const args = new Set(process.argv.slice(2))
+const keepTemp = args.has("--keep-temp")
+const skipBuild = args.has("--skip-build")
+const nodePath = requireNode26()
+
+const packageJson = JSON.parse(readFileSync(join(rootDir, "package.json"), "utf8")) as PackageJson
+const nativePackageName = `${packageJson.name}-${process.platform}-${process.arch}`
+const nativePackageDir = join(rootDir, "node_modules", nativePackageName)
+
+const declarationPaths = ["index.d.ts", "testing.d.ts", "lib/tree-sitter/parser.worker.d.ts"]
+
+function runCommand(
+  command: string,
+  commandArgs: string[],
+  cwd: string,
+  errorMessage: string,
+  options: { stdio?: "inherit" | "pipe" } = {},
+): SpawnSyncReturns<Buffer> {
+  const result = spawnSync(command, commandArgs, {
+    cwd,
+    stdio: options.stdio ?? "inherit",
+  })
+
+  if (result.error) {
+    throw new Error(`${errorMessage}: ${result.error.message}`)
+  }
+
+  if (result.status !== 0) {
+    throw new Error(errorMessage)
+  }
+
+  return result
+}
+
+function runCommandExpectFailure(
+  command: string,
+  commandArgs: string[],
+  cwd: string,
+  errorMessage: string,
+): SpawnSyncReturns<Buffer> {
+  const result = spawnSync(command, commandArgs, {
+    cwd,
+    stdio: "pipe",
+  })
+
+  if (result.error) {
+    throw new Error(`${errorMessage}: ${result.error.message}`)
+  }
+
+  if (result.status === 0) {
+    throw new Error(errorMessage)
+  }
+
+  return result
+}
+
+function ensureBuildArtifacts(): void {
+  if (!skipBuild) {
+    runCommand("bun", ["run", "build"], rootDir, "Dist test build failed")
+  }
+
+  if (!existsSync(distDir)) {
+    throw new Error(`Missing dist directory at ${distDir}. Run bun run build first.`)
+  }
+
+  if (!existsSync(nativePackageDir)) {
+    throw new Error(`Missing native package directory at ${nativePackageDir}. Run bun run build first.`)
+  }
+}
+
+function assertPortableDeclarations(): void {
+  for (const declarationPath of declarationPaths) {
+    const fullPath = join(distDir, declarationPath)
+    const contents = readFileSync(fullPath, "utf8")
+    if (contents.includes("bun:ffi")) {
+      throw new Error(`Portable declaration ${declarationPath} still references bun:ffi`)
+    }
+  }
+}
+
+function packArtifact(packageDir: string, packDir: string): string {
+  const result = runCommand(
+    "npm",
+    ["pack", "--pack-destination", packDir],
+    packageDir,
+    `Failed to pack ${packageDir}`,
+    {
+      stdio: "pipe",
+    },
+  )
+
+  const tarballName = result.stdout.toString("utf8").trim().split(/\r?\n/).at(-1)
+
+  if (!tarballName) {
+    throw new Error(`Failed to determine tarball name for ${packageDir}`)
+  }
+
+  return join(packDir, tarballName)
+}
+
+function writeConsumerPackage(consumerDir: string, coreTarball: string, nativeTarball: string, name: string): void {
+  const coreDependency = `file:${relative(consumerDir, coreTarball).replaceAll("\\", "/")}`
+  const nativeDependency = `file:${relative(consumerDir, nativeTarball).replaceAll("\\", "/")}`
+
+  writeFileSync(
+    join(consumerDir, "package.json"),
+    JSON.stringify(
+      {
+        name,
+        private: true,
+        type: "module",
+        dependencies: {
+          [packageJson.name]: coreDependency,
+          [nativePackageName]: nativeDependency,
+        },
+      },
+      null,
+      2,
+    ),
+  )
+}
+
+function writeNodeTest(nodeDir: string): void {
+  writeFileSync(
+    join(nodeDir, "index.mjs"),
+    `import assert from "node:assert/strict"
+
+const nativePackageName = ${JSON.stringify(nativePackageName)}
+
+const core = await import(${JSON.stringify(packageJson.name)})
+const testing = await import(${JSON.stringify(`${packageJson.name}/testing`)})
+const parserWorker = await import(${JSON.stringify(`${packageJson.name}/parser.worker`)})
+const nativePackage = await import(nativePackageName)
+
+assert.equal(typeof core.createCliRenderer, "function")
+assert.equal(typeof testing.createTestRenderer, "function")
+assert.equal(typeof parserWorker, "object")
+assert.equal(typeof nativePackage.default, "string")
+
+const expectBunOnlyFailure = async (specifier, expectedMessage) => {
+  await assert.rejects(import(specifier), (error) => {
+    return error instanceof Error && error.message.includes(expectedMessage)
+  })
+}
+
+await expectBunOnlyFailure(${JSON.stringify(`${packageJson.name}/runtime-plugin`)}, ${JSON.stringify(`${packageJson.name}/runtime-plugin is Bun-only`)})
+await expectBunOnlyFailure(
+  ${JSON.stringify(`${packageJson.name}/runtime-plugin-support`)},
+  ${JSON.stringify(`${packageJson.name}/runtime-plugin-support is Bun-only`)},
+)
+await expectBunOnlyFailure(
+  ${JSON.stringify(`${packageJson.name}/runtime-plugin-support/configure`)},
+  ${JSON.stringify(`${packageJson.name}/runtime-plugin-support/configure is Bun-only`)},
+)
+
+console.log("Node dist smoke test passed")
+`,
+  )
+
+  writeFileSync(
+    join(nodeDir, "require.cjs"),
+    `const assert = require("node:assert/strict")
+
+for (const specifier of [${JSON.stringify(packageJson.name)}, ${JSON.stringify(`${packageJson.name}/testing`)}, ${JSON.stringify(`${packageJson.name}/tree-sitter/update-assets`)}]) {
+  assert.throws(
+    () => require(specifier),
+    (error) => error?.code === "ERR_PACKAGE_PATH_NOT_EXPORTED",
+    \`Expected \${specifier} to remain import-only in Node\`,
+  )
+}
+
+const workerPath = require.resolve(${JSON.stringify(`${packageJson.name}/parser.worker`)})
+assert.match(workerPath, /parser\\.worker\\.js$/)
+
+console.log("Node CommonJS export smoke test passed")
+`,
+  )
+}
+
+function writeBunTest(bunDir: string): void {
+  writeFileSync(
+    join(bunDir, "index.test.ts"),
+    `import { describe, expect, test } from "bun:test"
+
+describe("${packageJson.name} dist smoke test", () => {
+  test("imports portable and Bun-only entrypoints", async () => {
+    const core = await import(${JSON.stringify(packageJson.name)})
+    const testing = await import(${JSON.stringify(`${packageJson.name}/testing`)})
+    const parserWorker = await import(${JSON.stringify(`${packageJson.name}/parser.worker`)})
+    const runtimePlugin = await import(${JSON.stringify(`${packageJson.name}/runtime-plugin`)})
+    const nativePackage = await import(${JSON.stringify(nativePackageName)})
+
+    expect(typeof core.createCliRenderer).toBe("function")
+    expect(typeof testing.createTestRenderer).toBe("function")
+    expect(typeof parserWorker).toBe("object")
+    expect(typeof runtimePlugin.createRuntimePlugin).toBe("function")
+    expect(typeof nativePackage.default).toBe("string")
+  })
+})
+`,
+  )
+}
+
+function assertNodeStaticImportFailure(
+  nodeDir: string,
+  importedName: string,
+  specifier: string,
+  expectedMessage: string,
+): void {
+  const result = runCommandExpectFailure(
+    nodePath,
+    ["--input-type=module", "-e", `import { ${importedName} } from ${JSON.stringify(specifier)}`],
+    nodeDir,
+    `Expected static Node import of ${specifier} to fail`,
+  )
+
+  const output = `${result.stdout.toString("utf8")}\n${result.stderr.toString("utf8")}`
+
+  if (output.includes("does not provide an export named")) {
+    throw new Error(`Static Node import of ${specifier} failed before the Bun-only stub could run`)
+  }
+
+  if (!output.includes(expectedMessage)) {
+    throw new Error(`Static Node import of ${specifier} did not report the expected Bun-only error`)
+  }
+}
+
+function installAndTest(nodeDir: string, bunDir: string): void {
+  runCommand("npm", ["install", "--ignore-scripts", "--no-package-lock"], nodeDir, "Node dist test install failed")
+  runCommand(nodePath, ["-e", `import(${JSON.stringify(packageJson.name)})`], nodeDir, "Node import smoke check failed")
+  runCommand(nodePath, ["index.mjs"], nodeDir, "Node dist smoke tests failed")
+  runCommand(nodePath, ["require.cjs"], nodeDir, "Node CommonJS export smoke tests failed")
+
+  assertNodeStaticImportFailure(
+    nodeDir,
+    "createRuntimePlugin",
+    `${packageJson.name}/runtime-plugin`,
+    `${packageJson.name}/runtime-plugin is Bun-only`,
+  )
+  assertNodeStaticImportFailure(
+    nodeDir,
+    "ensureRuntimePluginSupport",
+    `${packageJson.name}/runtime-plugin-support`,
+    `${packageJson.name}/runtime-plugin-support is Bun-only`,
+  )
+  assertNodeStaticImportFailure(
+    nodeDir,
+    "ensureRuntimePluginSupport",
+    `${packageJson.name}/runtime-plugin-support/configure`,
+    `${packageJson.name}/runtime-plugin-support/configure is Bun-only`,
+  )
+
+  runCommand("bun", ["install", "--ignore-scripts"], bunDir, "Bun dist test install failed")
+  runCommand("bun", ["test", "index.test.ts"], bunDir, "Bun dist smoke tests failed")
+}
+
+let tempRoot: string | undefined
+
+try {
+  ensureBuildArtifacts()
+  assertPortableDeclarations()
+
+  tempRoot = mkdtempSync(join(tmpdir(), "opentui-core-dist-test-"))
+  const packDir = join(tempRoot, "packs")
+  const nodeDir = join(tempRoot, "node")
+  const bunDir = join(tempRoot, "bun")
+
+  mkdirSync(packDir, { recursive: true })
+  mkdirSync(nodeDir, { recursive: true })
+  mkdirSync(bunDir, { recursive: true })
+
+  const coreTarball = packArtifact(distDir, packDir)
+  const nativeTarball = packArtifact(nativePackageDir, packDir)
+
+  writeConsumerPackage(nodeDir, coreTarball, nativeTarball, "opentui-core-dist-test-node")
+  writeConsumerPackage(bunDir, coreTarball, nativeTarball, "opentui-core-dist-test-bun")
+  writeNodeTest(nodeDir)
+  writeBunTest(bunDir)
+
+  installAndTest(nodeDir, bunDir)
+
+  if (!keepTemp) {
+    rmSync(tempRoot, { recursive: true, force: true })
+    tempRoot = undefined
+  }
+
+  console.log("Packed dist smoke tests passed")
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error)
+  if (tempRoot) {
+    console.error(`Dist test workspace kept at ${tempRoot}`)
+  }
+  process.exit(1)
+}

package/scripts/package-prebuilt.ts

@@ -0,0 +1,110 @@
+// package-prebuilt.ts — Package a pre-built .so into npm packages.
+//
+// This runs in GitHub Actions AFTER you commit a .so built natively on
+// Termux. It reads the .so from packages/core/prebuilt/<arch>/libopentui.so
+// and produces the three npm package directories that XINCLI's
+// resolveNativePackage() loads at runtime:
+//
+//   dist/@xincli/opentui-core-android-arm64/libopentui.so
+//   dist/@xincli/opentui-core-android-arm/libopentui.so   (if present)
+//   dist/@xincli/opentui-core-android-x64/libopentui.so   (if present)
+//
+// No Zig, no NDK, no cross-compilation. Just packaging.
+
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs"
+import { dirname, join, resolve } from "path"
+import { fileURLToPath } from "url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const rootDir = resolve(__dirname, "..")
+
+const PREBUILT_DIR = join(rootDir, "prebuilt")
+const DIST_DIR = join(rootDir, "dist-prebuilt")
+
+// Map prebuilt/ subdirectory names to npm package names.
+const ARCH_TO_PACKAGE: Record<string, string> = {
+  "aarch64-android": "@xincli/opentui-core-android-arm64",
+  "arm-android": "@xincli/opentui-core-android-arm",
+  "x86_64-android": "@xincli/opentui-core-android-x64",
+}
+
+function packageOne(archDir: string, packageName: string): void {
+  const soPath = join(PREBUILT_DIR, archDir, "libopentui.so")
+  if (!existsSync(soPath)) {
+    console.log(`⊘ Skipping ${packageName} — no .so at ${soPath}`)
+    return
+  }
+
+  const pkgDir = join(DIST_DIR, packageName)
+  mkdirSync(pkgDir, { recursive: true })
+  copyFileSync(soPath, join(pkgDir, "libopentui.so"))
+
+  // Read version from core package.json so the prebuilt packages stay in sync
+  const corePkg = JSON.parse(readFileSync(join(rootDir, "package.json"), "utf8"))
+
+  const pkgJson = {
+    name: packageName,
+    version: corePkg.version,
+    description: `OpenTUI native core for Android ${archDir} (Termux). Built natively, packaged by XINCLI.`,
+    repository: {
+      type: "git",
+      url: "git+https://github.com/bd-loser/opentui.git",
+    },
+    license: "MIT",
+    type: "module",
+    main: "index.js",
+    module: "index.js",
+    exports: {
+      ".": {
+        import: "./index.js",
+        types: "./index.d.ts",
+      },
+    },
+    files: ["libopentui.so", "index.js", "index.d.ts"],
+  }
+  
+  // Create index.js that exports the .so path (not the .so itself)
+  // This is what @opentui/core's resolveNativePackage expects:
+  //   const nativePackage = await import("@xincli/opentui-core-android-arm64")
+  //   const libPath = nativePackage.default  // ← path to libopentui.so
+  const indexJsContent = `import { fileURLToPath } from "node:url"
+
+export default fileURLToPath(new URL("./libopentui.so", import.meta.url))
+`
+  writeFileSync(join(pkgDir, "index.js"), indexJsContent)
+  
+  // Create index.d.ts
+  writeFileSync(join(pkgDir, "index.d.ts"), "declare const path: string\nexport default path\n")
+  
+  writeFileSync(join(pkgDir, "package.json"), JSON.stringify(pkgJson, null, 2))
+
+  const sizeKb = Math.round(existsSync(soPath) ? require("fs").statSync(soPath).size / 1024 : 0)
+  console.log(`✓ Packaged ${packageName} (${sizeKb} KB)`)
+}
+
+console.log("📦 Packaging prebuilt .so files...")
+console.log(`   prebuilt dir: ${PREBUILT_DIR}`)
+
+if (!existsSync(PREBUILT_DIR)) {
+  console.error(`❌ No prebuilt/ directory found. Run build-native-termux.sh on a phone first.`)
+  process.exit(1)
+}
+
+let packaged = 0
+for (const [archDir, packageName] of Object.entries(ARCH_TO_PACKAGE)) {
+  if (existsSync(join(PREBUILT_DIR, archDir, "libopentui.so"))) {
+    packageOne(archDir, packageName)
+    packaged++
+  }
+}
+
+if (packaged === 0) {
+  console.error(`❌ No .so files found in ${PREBUILT_DIR}.`)
+  console.error(`   Expected one of: ${Object.keys(ARCH_TO_PACKAGE).join(", ")}`)
+  console.error(`   Run build-native-termux.sh on a phone, then commit prebuilt/.`)
+  process.exit(1)
+}
+
+console.log(`\n✅ Packaged ${packaged} variant(s) → ${DIST_DIR}`)
+console.log("   Ready for npm publish.")

package/scripts/publish.ts

@@ -0,0 +1,60 @@
+import { spawnSync, type SpawnSyncReturns } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import process from "node:process"
+import { fileURLToPath } from "node:url"
+
+interface PackageJson {
+  name: string
+  version: string
+  optionalDependencies?: Record<string, string>
+}
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const rootDir = resolve(__dirname, "..")
+
+const packageJson: PackageJson = JSON.parse(readFileSync(join(rootDir, "package.json"), "utf8"))
+
+console.log(`Publishing @opentui/core@${packageJson.version}...`)
+console.log("Make sure you've run the pre-publish validation script first!")
+
+const libDir = join(rootDir, "dist")
+const packageJsons: Record<string, PackageJson> = {
+  [libDir]: JSON.parse(readFileSync(join(libDir, "package.json"), "utf8")),
+}
+
+// Load all native package.json files
+for (const pkgName of Object.keys(packageJsons[libDir].optionalDependencies!).filter((x) =>
+  x.startsWith(packageJson.name),
+)) {
+  const nativeDir = join(rootDir, "node_modules", pkgName)
+  packageJsons[nativeDir] = JSON.parse(readFileSync(join(nativeDir, "package.json"), "utf8"))
+}
+
+// Publish all packages (main + native packages)
+Object.entries(packageJsons).forEach(([dir, { name, version }]) => {
+  console.log(`\nPublishing ${name}@${version}...`)
+
+  const isSnapshot = version.includes("-snapshot") || /^0\.0\.0-\d{8}-[a-f0-9]{8}$/.test(version)
+  const publishArgs = ["publish", "--access=public"]
+
+  if (isSnapshot) {
+    publishArgs.push("--tag", "snapshot")
+    console.log(`  Publishing as snapshot (--tag snapshot)`)
+  }
+
+  const publish: SpawnSyncReturns<Buffer> = spawnSync("npm", publishArgs, {
+    cwd: dir,
+    stdio: "inherit",
+  })
+
+  if (publish.status !== 0) {
+    console.error(`Failed to publish '${name}@${version}'.`)
+    process.exit(1)
+  }
+
+  console.log(`Successfully published '${name}@${version}'`)
+})
+
+console.log(`\nAll @opentui/core packages published successfully!`)

package/scripts/test-node-hook.mjs

@@ -0,0 +1,16 @@
+import { registerHooks } from "node:module"
+
+const bunTestUrl = new URL("../.node-test/src/testing/bun-test-node.js", import.meta.url).href
+
+registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (specifier === "bun:test") {
+      return {
+        shortCircuit: true,
+        url: bunTestUrl,
+      }
+    }
+
+    return nextResolve(specifier, context)
+  },
+})