stovesdk.js 0.0.0-stage → 0.3.1

package/tools/check-tarball.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+'use strict'
+
+// Inspects the file list of `npm pack --dry-run --json` for what must and must not ship.
+//
+//   node tools/check-tarball.js <pack.json>                  source tree: no binary at all, nothing from the SDK (ci.yml)
+//   node tools/check-tarball.js <pack.json> --with-prebuild  publish: exactly prebuilds/win32-x64/stovesdk.node (+ SHA256SUMS), nothing from the SDK (publish.yml)
+//
+// The SDK is bring-your-own and is never redistributed: no sdk/ path, no .dll/.lib/.pdb/.h.
+// The one binary a published tarball may carry is the maintainer-built addon, and only there.
+//
+// `npm pack --json` is an array of one entry up to npm 11 and an object keyed by package name
+// from npm 12; packFiles() takes either.
+
+const PREBUILD = 'prebuilds/win32-x64/stovesdk.node'
+const SUMS = 'prebuilds/win32-x64/SHA256SUMS'
+const SDK_FILE = /^sdk\/|\.(dll|lib|pdb|exe|h|hpp)$/i
+const BINARY = /\.node$/i
+
+// The file paths of the one package in `npm pack --dry-run --json` output, whichever shape.
+function packFiles(json) {
+  const entry = Array.isArray(json) ? json[0] : json && typeof json === 'object' ? Object.values(json)[0] : undefined
+  if (!entry || !Array.isArray(entry.files)) throw new TypeError('not the output of `npm pack --json`: no package entry with a files list')
+  return { name: entry.name, version: entry.version, files: entry.files.map(f => f.path) }
+}
+
+function checkTarball(files, { withPrebuild = false } = {}) {
+  const problems = []
+  const sdk = files.filter(p => SDK_FILE.test(p))
+  if (sdk.length) problems.push(`would ship SDK material or a binary of the kind: ${sdk.join(', ')}`)
+  const binaries = files.filter(p => BINARY.test(p))
+  if (withPrebuild) {
+    for (const must of [PREBUILD, SUMS, 'index.js', 'index.d.ts', 'package.json']) {
+      if (!files.includes(must)) problems.push(`missing from the tarball: ${must}`)
+    }
+    const stray = binaries.filter(p => p !== PREBUILD)
+    if (stray.length) problems.push(`a binary other than the prebuild: ${stray.join(', ')}`)
+  } else if (binaries.length) {
+    problems.push(`a binary in the source tarball: ${binaries.join(', ')}`)
+  }
+  return problems
+}
+
+module.exports = { checkTarball, packFiles, PREBUILD, SUMS }
+
+if (require.main === module) {
+  const [file, flag] = process.argv.slice(2)
+  if (!file) {
+    console.error('usage: node tools/check-tarball.js <pack.json> [--with-prebuild]')
+    process.exit(2)
+  }
+  const { name, version, files } = packFiles(require(require('path').resolve(file)))
+  const withPrebuild = flag === '--with-prebuild'
+  const problems = checkTarball(files, { withPrebuild })
+  if (problems.length) {
+    for (const p of problems) console.error(`::error::${p}`)
+    process.exit(1)
+  }
+  console.log(`npm pack: ${files.length} files, ${name}@${version}, ${withPrebuild ? 'prebuild in, ' : 'no binary, '}nothing from the SDK`)
+}

package/tools/sdk-dir.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+'use strict'
+
+// Called by binding.gyp (`<!(node tools/sdk-dir.js)`) to print the SDK directory, after checking
+// that the layout lib/sdk-dir.js documents is present. Fails loudly otherwise — node-gyp would
+// fail a few seconds later anyway, but with a far less readable error.
+//
+//   node tools/sdk-dir.js            → prints the resolved SDK directory
+//   node tools/sdk-dir.js version    → prints the SDK version string ('unknown' if no VERSION file)
+//   node tools/sdk-dir.js check      → exit 0 if the layout is complete, 1 otherwise (prints what is missing)
+
+const { resolveSdkDir, missingSdkFiles, readSdkVersion } = require('../lib/sdk-dir')
+
+const sdkDir = resolveSdkDir()
+const mode = process.argv[2] || 'dir'
+
+if (mode === 'version') {
+  process.stdout.write(readSdkVersion(sdkDir))
+  process.exit(0)
+}
+
+const missing = missingSdkFiles(sdkDir)
+if (missing.length) {
+  process.stderr.write(`[stovesdk] STOVE PC SDK not found at ${sdkDir}\n`)
+  process.stderr.write('[stovesdk] Place the SDK under sdk/ or set STOVE_PCSDK_DIR (see sdk/README.md). Missing:\n')
+  for (const file of missing) process.stderr.write(`  - ${file}\n`)
+  process.exit(1)
+}
+
+if (mode === 'check') {
+  process.stdout.write(`[stovesdk] SDK layout OK at ${sdkDir} (version ${readSdkVersion(sdkDir)})\n`)
+  process.exit(0)
+}
+
+// gyp reads this verbatim; forward slashes keep it portable inside the generated project files.
+process.stdout.write(sdkDir.replace(/\\/g, '/'))

package/tools/smoke.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+'use strict'
+
+// Load-only smoke for a freshly built addon (Windows). Proves, without a STOVE client:
+//   1. the .node loads (its DLL imports resolve — the SDK DLLs must sit next to it or next to node.exe),
+//   2. the export surface matches index.d.ts,
+//   3. the pure-addon paths behave: refusals before initialize(), argument validation, no-op pump,
+//      no-op uninitialize().
+// Nothing initializes the SDK — that needs a STOVE client session on the machine.
+//
+//   node tools/smoke.js [path/to/stovesdk.node]
+
+const path = require('path')
+const { load } = require('..')
+
+const EXPECTED_EXPORTS = [
+  'getAddonInfo', 'getVersion', 'initialize', 'runCallbacks', 'isInitialized', 'uninitialize',
+  'getOwnershipList', 'getUser', 'getGds', 'getAchievement', 'getAllAchievements', 'getStat', 'setStat',
+]
+
+function fail(message) {
+  console.error(`[smoke] ${message}`)
+  process.exit(1)
+}
+
+const sdk = load(process.argv[2] ? path.resolve(process.argv[2]) : undefined)
+
+const missing = EXPECTED_EXPORTS.filter(name => typeof sdk[name] !== 'function')
+if (missing.length) fail(`missing exports: ${missing.join(', ')}`)
+if (!sdk.constants || !sdk.constants.OwnershipCode || !sdk.constants.OwnershipGameCode || !sdk.constants.ErrorCode) {
+  fail('constants are missing')
+}
+
+const info = sdk.getAddonInfo()
+console.log('[smoke] addon info:', JSON.stringify(info))
+console.log('[smoke] constants:', JSON.stringify(sdk.constants))
+
+if (sdk.isInitialized() !== false) fail('expected isInitialized() === false on a fresh load')
+
+// Informational — exercises a real call into BaseSDK.dll.
+console.log('[smoke] Base_GetVersion:', JSON.stringify(sdk.getVersion()))
+
+// Synchronous identity reads must answer, not throw, before initialize().
+for (const name of ['getUser', 'getGds']) {
+  const answer = sdk[name]()
+  console.log(`[smoke] ${name}() before init:`, JSON.stringify(answer))
+  if (!answer || answer.ok !== false || answer.code !== sdk.constants.ErrorCode.NOT_INITIALIZED) {
+    fail(`${name}() before init must report { ok: false, code: ErrorCode.NOT_INITIALIZED }`)
+  }
+}
+
+// runCallbacks() must be a no-op when nothing is in flight.
+sdk.runCallbacks()
+
+// uninitialize() on a fresh addon must be a harmless no-op with all three slots null.
+const down = sdk.uninitialize()
+console.log('[smoke] uninitialize() on fresh addon:', JSON.stringify(down))
+if (down.base !== null || down.ownership !== null || down.gameSupport !== null) {
+  fail('uninitialize() reported an UnInitialize on a never-initialized SDK')
+}
+
+// Argument validation is synchronous (TypeError / RangeError), never a crash and never an SDK call.
+function expectThrow(label, fn, ctor) {
+  try {
+    fn()
+  } catch (err) {
+    if (err instanceof ctor) {
+      console.log(`[smoke] ${label} threw ${ctor.name} as expected:`, err.message)
+      return
+    }
+    fail(`${label} threw the wrong error type: ${err}`)
+  }
+  fail(`${label} did not throw`)
+}
+expectThrow('initialize() without options', () => sdk.initialize(), TypeError)
+expectThrow('setStat("x") without a value', () => sdk.setStat('x'), TypeError)
+expectThrow('setStat("x", 1.5)', () => sdk.setStat('x', 1.5), RangeError)
+expectThrow('getAchievement(42)', () => sdk.getAchievement(42), TypeError)
+expectThrow('getStat(null)', () => sdk.getStat(null), TypeError)
+
+// Before initialize() every asynchronous entry point must reject through its Promise —
+// never crash the process, never reach the SDK.
+function expectReject(label, promise, step) {
+  return promise.then(
+    () => fail(`${label} resolved without the SDK initialized`),
+    err => {
+      if (!err || err.step !== step || err.code !== sdk.constants.ErrorCode.NOT_INITIALIZED) {
+        fail(`${label} rejected with an unexpected shape: step=${err && err.step} code=${err && err.code}`)
+      }
+      console.log(`[smoke] ${label} rejected as expected:`, err.message)
+    }
+  )
+}
+
+expectReject('getOwnershipList()', sdk.getOwnershipList(), 'ownershipList')
+  .then(() => expectReject('setStat("x", 1)', sdk.setStat('x', 1), 'modifyStat'))
+  .then(() => expectReject('getStat("x")', sdk.getStat('x'), 'stat'))
+  .then(() => expectReject('getAchievement("x")', sdk.getAchievement('x'), 'achievement'))
+  .then(() => expectReject('getAllAchievements()', sdk.getAllAchievements(), 'allAchievements'))
+  .then(() => {
+    console.log('[smoke] OK')
+  })

package/tools/syntax-check.sh

@@ -0,0 +1,34 @@
+#!/bin/sh
+# Parses src/stovesdk.cc with clang `-fsyntax-only` on a non-Windows machine, against the real
+# SDK headers (STOVE_PCSDK_DIR or ./sdk) and a stub <windows.h>. It catches typos, wrong SDK
+# accessor names and N-API misuse before the code reaches a Windows toolchain. It is NOT a build:
+# nothing is linked, and MSVC-only behaviour is not exercised.
+#
+#   sh tools/syntax-check.sh            (needs: clang++, node_modules/node-addon-api, Node headers)
+set -eu
+
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+SDK_DIR=$(node "$ROOT/tools/sdk-dir.js")
+NAPI_INC=$(node -p "require('$ROOT/node_modules/node-addon-api').include.replace(/\"/g, '')")
+NODE_INC="${NODE_INCLUDE_DIR:-$(dirname "$(dirname "$(command -v node)")")/include/node}"
+[ -f "$NODE_INC/node_api.h" ] || { echo "node_api.h not found under $NODE_INC (set NODE_INCLUDE_DIR)" >&2; exit 1; }
+
+STUB=$(mktemp -d)
+trap 'rm -rf "$STUB"' EXIT
+cat > "$STUB/windows.h" <<'EOF'
+// Minimal stand-in for <windows.h>: only what src/stovesdk.cc and the SDK headers touch.
+#pragma once
+#include <cstdint>
+#define __cdecl
+#define CP_UTF8 65001
+#define __out
+extern "C" int WideCharToMultiByte(unsigned, unsigned long, const wchar_t*, int, char*, int, const char*, int*);
+EOF
+
+clang++ -fsyntax-only -std=c++17 -fshort-wchar -fdeclspec -fms-extensions \
+  -Wno-ignored-attributes -Wno-microsoft -Wno-pragma-pack \
+  -DSTOVE_PCSDK_SYNTAX_CHECK -DNAPI_VERSION=8 -DNAPI_DISABLE_CPP_EXCEPTIONS \
+  -I "$STUB" -I "$NAPI_INC" -I "$NODE_INC" \
+  -I "$SDK_DIR" -I "$SDK_DIR/BaseSDK/Deploy/Include" -I "$SDK_DIR/OwnershipSDK/Deploy/Include" -I "$SDK_DIR/GameSupportSDK/Deploy/Include" \
+  "$ROOT/src/stovesdk.cc"
+echo "[syntax-check] OK: src/stovesdk.cc parses against the SDK headers at $SDK_DIR"