@metaverse-systems/the-seed 1.0.2 → 1.2.0

package/dist/types.d.ts

@@ -10,7 +10,6 @@ export interface ScopesType {
     [index: string]: ScopeType;
 }
 export interface ConfigType {
-    [index: string]: any;
     prefix: string;
     scopes: ScopesType;
 }
@@ -19,3 +18,45 @@ export interface ScriptArgsType {
     args: string[];
     configDir: string;
 }
+export interface ResourceType {
+    name: string;
+    filename: string;
+    size: number;
+    attributes?: {
+        [key: string]: string;
+    };
+}
+export interface PackageType {
+    author: AuthorType;
+    name: string;
+    license: string;
+    version: string;
+    scripts: {
+        [index: string]: string;
+    };
+    resources: ResourceType[];
+    main?: string;
+}
+export interface ScopeAnswersType {
+    scopeName: string;
+    authorName: string;
+    authorEmail: string;
+    authorURL: string;
+}
+export interface ScopeDefaultsType {
+    name?: string;
+    email?: string;
+    url?: string;
+}
+export interface DependencyResultType {
+    dependencies: Record<string, string[]>;
+    errors: Record<string, string>;
+}
+export interface BuildStep {
+    /** Human-readable step name (e.g., 'autogen', 'configure', 'compile', 'install') */
+    label: string;
+    /** Shell command to execute */
+    command: string;
+    /** If true, non-zero exit codes do not abort the build (used for 'make distclean') */
+    ignoreExitCode?: boolean;
+}

package/native/binding.gyp

@@ -0,0 +1,20 @@
+{
+  "targets": [
+    {
+      "target_name": "dependency_lister",
+      "sources": ["src/addon.cpp"],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")",
+        "<!@(pkg-config --cflags-only-I the-seed | sed 's/-I//g')"
+      ],
+      "libraries": [
+        "<!@(pkg-config --libs the-seed)",
+        "<!@(pkg-config --libs-only-L the-seed | sed 's/-L/-Wl,-rpath,/g')"
+      ],
+      "cflags!": ["-fno-exceptions"],
+      "cflags_cc!": ["-fno-exceptions"],
+      "cflags_cc": ["-std=c++20"],
+      "defines": ["NAPI_DISABLE_CPP_EXCEPTIONS"]
+    }
+  ]
+}

package/native/src/addon.cpp

@@ -0,0 +1,60 @@
+#include <napi.h>
+#include <libthe-seed/DependencyLister.hpp>
+#include <string>
+#include <vector>
+#include <map>
+
+Napi::Value ListDependencies(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2 || !info[0].IsArray() || !info[1].IsArray()) {
+    Napi::TypeError::New(env, "Expected two array arguments: binaryPaths, searchPaths")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Array jsBinaryPaths = info[0].As<Napi::Array>();
+  Napi::Array jsSearchPaths = info[1].As<Napi::Array>();
+
+  std::vector<std::string> binaryPaths;
+  for (uint32_t i = 0; i < jsBinaryPaths.Length(); i++) {
+    binaryPaths.push_back(jsBinaryPaths.Get(i).As<Napi::String>().Utf8Value());
+  }
+
+  std::vector<std::string> searchPaths;
+  for (uint32_t i = 0; i < jsSearchPaths.Length(); i++) {
+    searchPaths.push_back(jsSearchPaths.Get(i).As<Napi::String>().Utf8Value());
+  }
+
+  DependencyLister lister;
+  auto result = lister.ListDependencies(binaryPaths, searchPaths);
+
+  Napi::Object jsResult = Napi::Object::New(env);
+
+  // Convert dependencies map: Record<string, string[]>
+  Napi::Object jsDeps = Napi::Object::New(env);
+  for (const auto& [libPath, dependents] : result.dependencies) {
+    Napi::Array jsDependents = Napi::Array::New(env, dependents.size());
+    for (size_t i = 0; i < dependents.size(); i++) {
+      jsDependents.Set(i, Napi::String::New(env, dependents[i]));
+    }
+    jsDeps.Set(libPath, jsDependents);
+  }
+  jsResult.Set("dependencies", jsDeps);
+
+  // Convert errors map: Record<string, string>
+  Napi::Object jsErrors = Napi::Object::New(env);
+  for (const auto& [binaryPath, errorMsg] : result.errors) {
+    jsErrors.Set(binaryPath, Napi::String::New(env, errorMsg));
+  }
+  jsResult.Set("errors", jsErrors);
+
+  return jsResult;
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  exports.Set("listDependencies", Napi::Function::New(env, ListDependencies));
+  return exports;
+}
+
+NODE_API_MODULE(dependency_lister, Init)

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@metaverse-systems/the-seed",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "The Seed",
   "main": "dist/index.js",
   "scripts": {
     "lint": "./node_modules/eslint/bin/eslint.js src/*",
     "lint-fix": "./node_modules/eslint/bin/eslint.js src/* --fix",
     "build": "tsc",
+    "build-addon": "node-gyp rebuild --directory=native",
     "test": "./node_modules/jest/bin/jest.js"
   },
   "repository": {
@@ -22,6 +23,7 @@
   "dependencies": {
     "fs-extra": "^10.0.1",
     "inquirer": "^8.2.2",
+    "node-addon-api": "^5.0.0",
     "tslib": "^2.3.1",
     "typescript": "^4.6.2"
   },
@@ -30,6 +32,7 @@
   },
   "keywords": [],
   "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^8.2.0",
     "@types/jest": "^27.4.1",
     "@types/node": "^17.0.21",

package/src/Build.ts

@@ -1,19 +1,19 @@
 import Config from "./Config";
-const { execSync } = require('child_process');
+import { execSync } from "child_process";
+import { BuildStep } from "./types";
 
-const targets: {
-  [key:string]: string;
+export const targets: {
+  [key: string]: string;
 } = {
-  "native": "x86_64-linux-gnu",
-  "windows": "x86_64-w64-mingw32",
-  "wasm": "wasm32-unknown-emscripten",
+  native: "x86_64-linux-gnu",
+  windows: "x86_64-w64-mingw32",
 };
 
-const execOptions = {stdio : 'pipe' };
+const execOptions = { stdio: "pipe" as const };
 
 class Build {
   config: Config;
-  target: string = "linux";
+  target = "linux";
 
   constructor(config: Config) {
     this.config = config;
@@ -29,22 +29,24 @@ class Build {
     }
 
     console.log("Completed " + autogen_command);
-  }
+  };
 
   configure = () => {
     const newTarget = targets[this.target];
     const distclean_command = "make distclean";
     try {
       const result = execSync(distclean_command, execOptions).toString();
-    } catch (e) {
-    }
+    } catch (e) {}
 
     const prefix = this.config.config.prefix + "/" + newTarget;
 
-    const configure_command = "PKG_CONFIG_PATH=" + prefix + "/lib/pkgconfig/ " +
-        (this.target === "wasm" ? "emconfigure " : "") + 
-        "./configure --prefix=" + prefix + 
-        (this.target === "windows" ? " --host=" + targets["windows"] : "");
+    const configure_command =
+      "PKG_CONFIG_PATH=" +
+      prefix +
+      "/lib/pkgconfig/ " +
+      "./configure --prefix=" +
+      prefix +
+      (this.target === "windows" ? " --host=" + targets["windows"] : "");
 
     try {
       const result = execSync(configure_command, execOptions).toString();
@@ -54,18 +56,16 @@ class Build {
     }
 
     console.log("Configure complete");
-  }
+  };
 
   reconfigure = (target: string) => {
     this.target = target;
     this.autogen();
     this.configure();
-  }
+  };
 
   compile = () => {
-    const make_command = this.target === "wasm" ?
-        "emmake make" :
-        "make -j";
+    const make_command = "make -j";
 
     try {
       const result = execSync(make_command).toString();
@@ -74,19 +74,69 @@ class Build {
       console.error(e);
       throw e;
     }
-  }
+  };
 
   install = () => {
     const install_command = "make install";
 
-   try {
+    try {
       const result = execSync(install_command).toString();
       console.log(result);
     } catch (e) {
       console.error(e);
       throw e;
     }
-  }
+  };
+
+  /**
+   * Returns an ordered array of BuildStep objects for the given target and mode.
+   * @param target - 'native' or 'windows'
+   * @param fullReconfigure - if true, includes autogen/distclean/configure steps; if false, only compile+install
+   */
+  getSteps = (target: string, fullReconfigure: boolean): BuildStep[] => {
+    const newTarget = targets[target];
+    const prefix = this.config.config.prefix + "/" + newTarget;
+
+    const steps: BuildStep[] = [];
+
+    if (fullReconfigure) {
+      steps.push({
+        label: "autogen",
+        command: "./autogen.sh",
+      });
+
+      steps.push({
+        label: "distclean",
+        command: "make distclean",
+        ignoreExitCode: true,
+      });
+
+      const configureCommand =
+        "PKG_CONFIG_PATH=" +
+        prefix +
+        "/lib/pkgconfig/ " +
+        "./configure --prefix=" +
+        prefix +
+        (target === "windows" ? " --host=" + targets["windows"] : "");
+
+      steps.push({
+        label: "configure",
+        command: configureCommand,
+      });
+    }
+
+    steps.push({
+      label: "compile",
+      command: "make -j",
+    });
+
+    steps.push({
+      label: "install",
+      command: "make install",
+    });
+
+    return steps;
+  };
 }
 
 export default Build;

package/src/Config.ts

@@ -10,13 +10,17 @@ class Config {
     scopes: {}
   };
 
-  constructor(configDir: string | undefined) {
-    this.configDir = configDir || os.homedir() + "/.the-seed";
+  constructor(configDir?: string) {
+    this.configDir = configDir || os.homedir() + "/the-seed";
     this.configFile = "/config.json";
     this.loadConfig();
   }
 
   loadConfig = () => {
+    // if file does not exist, create it
+    if (!fs.existsSync(this.configDir + this.configFile)) {
+      this.saveConfig();
+    }
     this.config = JSON.parse(fs.readFileSync(this.configDir + this.configFile).toString());
   };
 
@@ -29,15 +33,13 @@ class Config {
       {
         name: "prefix",
         message: "Installation prefix?",
-        default: this.config["prefix"]
+        default: this.config.prefix
       }
     ];
   };
 
-  parseAnswers = (answers: { [index:string]: any }) => {
-    Object.keys(answers).forEach((k) => {
-      this.config[k] = answers[k];
-    });
+  parseAnswers = (answers: { prefix: string }) => {
+    this.config.prefix = answers.prefix;
   };
 }
 

package/src/Dependencies.ts

@@ -0,0 +1,73 @@
+import Config from "./Config";
+import { execSync } from "child_process";
+import { targets } from "./Build";
+
+const execOptions = { stdio: "pipe" as const, shell: "/bin/bash", env: { ...process.env } };
+const libEcsRepo = "https://github.com/metaverse-systems/libecs-cpp.git";
+const libTheSeedRepo = "https://github.com/metaverse-systems/libthe-seed.git";
+
+export const checkLib = (config: Config, library: string, target: string) => {
+  const targetPrefix = targets[target];
+  const prefix = config.config.prefix + "/" + targetPrefix;
+  const pkgConfigCommand =
+    "PKG_CONFIG_PATH=" +
+    prefix +
+    "/lib/pkgconfig/ " +
+    "pkg-config --cflags --libs " +
+    library;
+  try {
+    const result = execSync(pkgConfigCommand, execOptions).toString();
+    if (result.includes(library)) {
+      return true;
+    }
+    console.error("pkg-config did not find " + library);
+  } catch (e) {
+    return false;
+  }
+  return false;
+};
+
+export const checkLibEcs = (config: Config, target: string) => {
+  return checkLib(config, "ecs-cpp", target);
+};
+
+export const checkLibTheSeed = (config: Config, target: string) => {
+  return checkLib(config, "the-seed", target);
+};
+
+export const installLibEcs = (config: Config, target: string) => {
+  if(installLib(config, libEcsRepo, "libecs-cpp", target)) {
+    return true;
+  }
+  console.error("Failed to build libecs-cpp");
+  return false;
+};
+
+export const installLibTheSeed = (config: Config, target: string) => {
+  if(installLib(config, libTheSeedRepo, "libthe-seed", target)) {
+    return true;
+  }
+  console.error("Failed to build libthe-seed");
+  return false;
+};
+
+export const installLib = (config: Config, repo: string, installDir: string, target: string) => {
+  const targetDir = targets[target];
+  const prefix = config.config.prefix + "/" + targetDir;
+  const cloneCommand = "git clone " + repo;
+  try {
+    const result = execSync(cloneCommand, execOptions).toString();
+  } catch (e) {
+    console.error("Failed to clone " + repo);
+  }
+  const buildCommand =
+    "cd " + installDir + " && ./autogen.sh && ./configure --prefix=" +
+    prefix + (target != "native" ? " --host=" + targetDir : "") +
+    " && make && make install";
+  try {
+    const result = execSync(buildCommand, execOptions).toString();
+  } catch (e) {
+    return false;
+  }
+  return true;
+};