@dekaruntime/deka 0.0.0 → 0.53.4

package/bin.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+'use strict';
+
+// @dekaruntime/deka: a thin wrapper that resolves and execs the platform
+// binary installed via optionalDependencies. It ships both the `deka` and
+// `dsc` commands (package.json's "bin" field points both names at this same
+// file) -- which one to run is decided by how the file was invoked.
+//
+// Kept intentionally requireable-without-side-effects (guarded by the
+// require.main check below) so tests can exercise resolveBinaryName,
+// makeExtraEnv and main() directly.
+const path = require('path');
+const fs = require('fs');
+const core = require('./launcher-core');
+
+function resolveBinaryName(argv1) {
+  const invokedAs = path.basename(argv1 || 'deka');
+  return invokedAs === 'dsc' ? 'dsc' : 'deka';
+}
+
+// When running the `deka` command, point DEKA_DSC at the dsc bundled
+// alongside this platform's deka binary. This is belt-and-braces for
+// find_cli_dsc() (deka check/fmt/transpile/lsp), which does consult the
+// environment; the runtime's own find_dsc() is sibling-only and does not
+// read DEKA_DSC, so correctness never depends on this.
+function makeExtraEnv(binaryName) {
+  return function extraEnv(pkgDir, env) {
+    if (binaryName !== 'deka') return env;
+    const dscPath = path.join(pkgDir, 'bin', 'dsc');
+    if (!fs.existsSync(dscPath)) return env;
+    return Object.assign({}, env, { DEKA_DSC: dscPath });
+  };
+}
+
+function main(argv = process.argv) {
+  const binaryName = resolveBinaryName(argv[1]);
+  return core.run({
+    family: 'deka',
+    platformPackagePrefix: '@dekaruntime/deka',
+    binaryName,
+    launcherDir: __dirname,
+    extraEnv: makeExtraEnv(binaryName),
+  });
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(`deka: ${err.message}`);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = { resolveBinaryName, makeExtraEnv, main };

package/launcher-core.js

@@ -0,0 +1,150 @@
+'use strict';
+
+// Shared launcher logic for the @dekaruntime/deka and @dekaruntime/dsc
+// wrappers. This exact file is duplicated byte-for-byte at
+// npm/dsc/launcher-core.js -- see test/launcher-core-parity.test.js, which
+// fails the build if the two copies drift. It is duplicated rather than
+// imported because each package must be self-contained once published: npm
+// only packs files inside a package's own directory, so a launcher cannot
+// `require('../deka/launcher-core')` after install.
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const { spawn } = require('child_process');
+
+// Platforms deka and dsc publish prebuilt binaries for today. Anything else
+// (Windows included) gets a clear message instead of a stack trace --
+// see https://github.com/dekaruntime/deka/issues/1092.
+const SUPPORTED_PLATFORMS = new Set(['darwin-arm64', 'darwin-x64', 'linux-x64']);
+
+function platformKey(platform = os.platform(), arch = os.arch()) {
+  return `${platform}-${arch}`;
+}
+
+function isSupportedPlatform(key) {
+  return SUPPORTED_PLATFORMS.has(key);
+}
+
+function unsupportedPlatformMessage(family, key) {
+  return [
+    `${family}: unsupported platform "${key}".`,
+    'Prebuilt binaries are published for darwin-arm64, darwin-x64 and linux-x64 only.',
+    'Windows support is tracked at https://github.com/dekaruntime/deka/issues/1092.',
+  ].join('\n');
+}
+
+// Resolve the installed directory of a platform package (e.g.
+// @dekaruntime/deka-darwin-arm64). Tries standard module resolution first --
+// this covers both local installs and the common global-install layout,
+// where npm links the platform package as a sibling of the launcher. Falls
+// back to a manual check under the launcher's own node_modules, because npm
+// sometimes nests optionalDependencies there instead (the case tana's
+// bin.js was written to handle).
+function resolvePlatformPackageDir(pkgName, launcherDir, overrides = {}) {
+  const resolve = overrides.resolve || require.resolve;
+  const existsSync = overrides.existsSync || fs.existsSync;
+
+  try {
+    return path.dirname(resolve(`${pkgName}/package.json`));
+  } catch {
+    // Fall through to the nesting fallback below.
+  }
+
+  const nested = path.join(launcherDir, 'node_modules', pkgName);
+  if (existsSync(path.join(nested, 'package.json'))) {
+    return nested;
+  }
+
+  return null;
+}
+
+// Run the resolved platform binary, forwarding argv, stdio, SIGINT/SIGTERM
+// and the exit code. Returns a promise that resolves once the child has
+// exited (or could not be started), after process.exitCode has been set --
+// callers should not call process.exit() themselves, so stdio has a chance
+// to flush.
+function run(opts) {
+  const {
+    family,
+    platformPackagePrefix,
+    binaryName,
+    launcherDir,
+    platform,
+    arch,
+    argv = process.argv.slice(2),
+    extraEnv,
+    resolveDir,
+  } = opts;
+
+  const key = platformKey(platform, arch);
+
+  if (!isSupportedPlatform(key)) {
+    console.error(unsupportedPlatformMessage(family, key));
+    process.exitCode = 1;
+    return Promise.resolve({ code: 1, signal: null });
+  }
+
+  const pkgName = `${platformPackagePrefix}-${key}`;
+  const pkgDir = resolveDir
+    ? resolveDir(pkgName, launcherDir)
+    : resolvePlatformPackageDir(pkgName, launcherDir);
+
+  if (!pkgDir) {
+    console.error(`${family}: could not locate ${pkgName}. Try reinstalling ${family}.`);
+    process.exitCode = 1;
+    return Promise.resolve({ code: 1, signal: null });
+  }
+
+  const binaryPath = path.join(pkgDir, 'bin', binaryName);
+  if (!fs.existsSync(binaryPath)) {
+    console.error(`${family}: ${binaryPath} is missing. Try reinstalling ${family}.`);
+    process.exitCode = 1;
+    return Promise.resolve({ code: 1, signal: null });
+  }
+
+  const env = extraEnv ? extraEnv(pkgDir, process.env) : process.env;
+
+  return new Promise((resolvePromise) => {
+    const child = spawn(binaryPath, argv, { stdio: 'inherit', env });
+
+    const forward = (signal) => {
+      child.kill(signal);
+    };
+    process.on('SIGINT', forward);
+    process.on('SIGTERM', forward);
+
+    const cleanup = () => {
+      process.removeListener('SIGINT', forward);
+      process.removeListener('SIGTERM', forward);
+    };
+
+    child.on('error', (err) => {
+      cleanup();
+      console.error(`${family}: failed to launch ${binaryPath}: ${err.message}`);
+      process.exitCode = 1;
+      resolvePromise({ code: 1, signal: null });
+    });
+
+    child.on('exit', (code, signal) => {
+      cleanup();
+      if (signal) {
+        // POSIX/bash convention: 128 + signal number. Deterministic and
+        // matches what a shell reports for a signal-terminated process.
+        const signalNumber = os.constants.signals[signal];
+        process.exitCode = signalNumber ? 128 + signalNumber : 1;
+      } else {
+        process.exitCode = code === null ? 1 : code;
+      }
+      resolvePromise({ code: process.exitCode, signal });
+    });
+  });
+}
+
+module.exports = {
+  SUPPORTED_PLATFORMS,
+  platformKey,
+  isSupportedPlatform,
+  unsupportedPlatformMessage,
+  resolvePlatformPackageDir,
+  run,
+};

package/package.json

@@ -1,11 +1,38 @@
 {
   "name": "@dekaruntime/deka",
-  "version": "0.0.0",
-  "description": "placeholder \u2014 the deka launcher, published by CI",
-  "license": "Apache-2.0",
+  "version": "0.53.4",
+  "description": "deka runtime launcher. Resolves and execs the platform binary installed via optionalDependencies; ships both the deka and dsc commands.",
+  "bin": {
+    "deka": "bin.js",
+    "dsc": "bin.js"
+  },
+  "files": [
+    "bin.js",
+    "launcher-core.js"
+  ],
+  "dependencies": {
+    "@dekaruntime/dsc": "0.53.4"
+  },
+  "optionalDependencies": {
+    "@dekaruntime/deka-darwin-arm64": "0.53.4",
+    "@dekaruntime/deka-darwin-x64": "0.53.4",
+    "@dekaruntime/deka-linux-x64": "0.53.4"
+  },
+  "engines": {
+    "node": ">=18"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/dekaruntime/create-deka-app.git"
+    "url": "git+https://github.com/dekaruntime/create-deka-app.git",
+    "directory": "npm/deka"
   },
-  "homepage": "https://deka.gg"
+  "homepage": "https://deka.gg",
+  "bugs": "https://github.com/dekaruntime/deka/issues",
+  "license": "Apache-2.0",
+  "keywords": [
+    "deka",
+    "dekascript",
+    "runtime",
+    "cli"
+  ]
 }

package/README.md

@@ -1 +0,0 @@
-Placeholder. Real contents are published by CI from dekaruntime/create-deka-app.