@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/workers/registry.js

@@ -0,0 +1,241 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultWorkerRegistryPath = defaultWorkerRegistryPath;
+exports.readWorkerRegistry = readWorkerRegistry;
+exports.resolveWorkerRoute = resolveWorkerRoute;
+exports.parseWorkerRegistry = parseWorkerRegistry;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../shared/errors");
+const product_storage_1 = require("./product-storage");
+function defaultWorkerRegistryPath() {
+    return node_path_1.default.join((0, product_storage_1.productStorageRoot)(), "workers", "worker-routes.json");
+}
+function readWorkerRegistry(registryPath = defaultWorkerRegistryPath()) {
+    if (!node_fs_1.default.existsSync(registryPath)) {
+        throw new errors_1.CliError("WORKER_REGISTRY_NOT_FOUND", "Worker registry was not found.", {
+            registryPath,
+            hint: "Run the control-plane worker with --manifest to fetch and activate remote worker routes."
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(node_fs_1.default.readFileSync(registryPath, "utf8"));
+    }
+    catch (error) {
+        throw new errors_1.CliError("WORKER_REGISTRY_MALFORMED", "Worker registry is not valid JSON.", {
+            registryPath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return parseWorkerRegistry(parsed, registryPath);
+}
+function resolveWorkerRoute(options) {
+    const registryPath = node_path_1.default.resolve(options.registryPath ?? defaultWorkerRegistryPath());
+    const registry = readWorkerRegistry(registryPath);
+    const route = registry.routes.find((item) => item.route === options.route);
+    if (!route) {
+        throw new errors_1.CliError("WORKER_ROUTE_NOT_FOUND", `Worker route was not found: ${options.route}`, {
+            route: options.route,
+            registryPath,
+            availableRoutes: registry.routes.map((item) => item.route).sort()
+        });
+    }
+    if (!route.enabled) {
+        throw new errors_1.CliError("WORKER_ROUTE_DISABLED", `Worker route is disabled: ${options.route}`, {
+            route: options.route,
+            registryPath
+        });
+    }
+    if (route.minCliVersion && !isCliVersionCompatible(options.cliVersion, route.minCliVersion)) {
+        throw new errors_1.CliError("WORKER_ROUTE_INCOMPATIBLE", `Worker route requires AIB ${route.minCliVersion}.`, {
+            route: options.route,
+            registryPath,
+            cliVersion: options.cliVersion,
+            minCliVersion: route.minCliVersion
+        });
+    }
+    const root = (0, product_storage_1.productStorageRoot)();
+    const script = resolveWorkerEntryScript(root, route, registryPath);
+    if (!node_fs_1.default.existsSync(script) || !node_fs_1.default.statSync(script).isFile()) {
+        throw new errors_1.CliError("WORKER_ENTRY_NOT_FOUND", "Worker entry file was not found.", {
+            route: options.route,
+            registryPath,
+            entry: route.entry,
+            script
+        });
+    }
+    return {
+        registryPath,
+        productStorageRoot: root,
+        route,
+        script
+    };
+}
+function resolveWorkerEntryScript(root, route, registryPath) {
+    if (route.entry.startsWith("worker-bundle:")) {
+        const workerId = route.entry.slice("worker-bundle:".length);
+        if (!workerId || !/^[a-zA-Z0-9._-]+$/.test(workerId)) {
+            throw new errors_1.CliError("WORKER_BUNDLE_ENTRY_INVALID", "Worker bundle entry is invalid.", {
+                route: route.route,
+                registryPath,
+                entry: route.entry
+            });
+        }
+        const statusPath = node_path_1.default.join(root, "workers", "bundles", workerId, "activation-status.json");
+        const status = readJsonObject(statusPath);
+        const active = status?.active && typeof status.active === "object" && !Array.isArray(status.active)
+            ? status.active
+            : null;
+        const activeEntry = typeof active?.entry === "string" ? active.entry : null;
+        if (!activeEntry) {
+            throw new errors_1.CliError("WORKER_BUNDLE_NOT_ACTIVE", "Worker bundle has no active version.", {
+                route: route.route,
+                workerId,
+                statusPath
+            });
+        }
+        const script = resolveInside(root, activeEntry);
+        if (!script) {
+            throw new errors_1.CliError("WORKER_BUNDLE_ENTRY_UNSAFE", "Worker bundle active entry must resolve inside product storage.", {
+                route: route.route,
+                workerId,
+                statusPath,
+                activeEntry
+            });
+        }
+        return script;
+    }
+    const script = resolveInside(root, route.entry);
+    if (!script) {
+        throw new errors_1.CliError("WORKER_ENTRY_UNSAFE", "Worker entry must resolve inside product storage.", {
+            route: route.route,
+            registryPath,
+            entry: route.entry,
+            productStorageRoot: root
+        });
+    }
+    return script;
+}
+function parseWorkerRegistry(value, registryPath = "<memory>") {
+    const object = asRecord(value, "worker registry");
+    if (object.schemaVersion !== 1) {
+        throw new errors_1.CliError("WORKER_REGISTRY_INVALID", "Worker registry schemaVersion must be 1.", {
+            registryPath
+        });
+    }
+    const routesValue = object.routes;
+    if (!Array.isArray(routesValue)) {
+        throw new errors_1.CliError("WORKER_REGISTRY_INVALID", "Worker registry routes must be an array.", {
+            registryPath
+        });
+    }
+    const routes = routesValue.map((item, index) => parseRoute(item, index, registryPath));
+    const seen = new Set();
+    for (const route of routes) {
+        if (seen.has(route.route)) {
+            throw new errors_1.CliError("WORKER_REGISTRY_INVALID", `Duplicate worker route: ${route.route}`, {
+                registryPath,
+                route: route.route
+            });
+        }
+        seen.add(route.route);
+    }
+    return {
+        schemaVersion: 1,
+        ...(typeof object.generatedAt === "string" ? { generatedAt: object.generatedAt } : {}),
+        ...(typeof object.registryVersion === "string" ? { registryVersion: object.registryVersion } : {}),
+        routes
+    };
+}
+function parseRoute(value, index, registryPath) {
+    const object = asRecord(value, `worker route ${index}`);
+    const route = readNonEmptyString(object.route, "route", index, registryPath);
+    const workerId = readNonEmptyString(object.workerId, "workerId", index, registryPath);
+    const version = readNonEmptyString(object.version, "version", index, registryPath);
+    const entry = readNonEmptyString(object.entry, "entry", index, registryPath);
+    const argsMode = object.argsMode === undefined ? "passthrough" : object.argsMode;
+    const output = object.output === undefined ? "json" : object.output;
+    if (argsMode !== "passthrough") {
+        throw invalidRoute("argsMode must be passthrough", index, registryPath);
+    }
+    if (output !== "json") {
+        throw invalidRoute("output must be json", index, registryPath);
+    }
+    return {
+        route,
+        workerId,
+        version,
+        entry,
+        argsMode: "passthrough",
+        output: "json",
+        enabled: object.enabled !== false,
+        ...(typeof object.minCliVersion === "string" && object.minCliVersion.trim() ? { minCliVersion: object.minCliVersion } : {}),
+        capabilities: Array.isArray(object.capabilities)
+            ? object.capabilities.filter((item) => typeof item === "string")
+            : []
+    };
+}
+function asRecord(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new errors_1.CliError("WORKER_REGISTRY_INVALID", `${label} must be an object.`);
+    }
+    return value;
+}
+function readNonEmptyString(value, field, index, registryPath) {
+    if (typeof value === "string" && value.trim()) {
+        return value;
+    }
+    throw invalidRoute(`${field} is required`, index, registryPath);
+}
+function invalidRoute(message, index, registryPath) {
+    return new errors_1.CliError("WORKER_REGISTRY_INVALID", `Invalid worker route at index ${index}: ${message}.`, {
+        registryPath,
+        index
+    });
+}
+function resolveInside(root, relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/");
+    if (!normalized || normalized.startsWith("/") || normalized.split("/").includes("..")) {
+        return null;
+    }
+    const resolvedRoot = node_path_1.default.resolve(root);
+    const resolved = node_path_1.default.resolve(resolvedRoot, normalized);
+    const relative = node_path_1.default.relative(resolvedRoot, resolved);
+    return relative && !relative.startsWith("..") && !node_path_1.default.isAbsolute(relative) ? resolved : null;
+}
+function readJsonObject(filePath) {
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isCliVersionCompatible(current, required) {
+    const match = required.match(/^>=\s*(\d+)\.(\d+)\.(\d+)$/);
+    if (!match) {
+        return current === required;
+    }
+    const currentParts = parseVersion(current);
+    const requiredParts = match.slice(1).map((item) => Number(item));
+    for (let index = 0; index < 3; index += 1) {
+        const currentPart = currentParts[index] ?? 0;
+        const requiredPart = requiredParts[index] ?? 0;
+        if (currentPart > requiredPart) {
+            return true;
+        }
+        if (currentPart < requiredPart) {
+            return false;
+        }
+    }
+    return true;
+}
+function parseVersion(value) {
+    const match = value.match(/(\d+)\.(\d+)\.(\d+)/);
+    return match ? match.slice(1).map((item) => Number(item)) : [0, 0, 0];
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@automaton-labs/aib",
-  "version": "0.0.6",
-  "description": "CLI for discovering and calling the local aib IDE extension runtime.",
+  "version": "0.0.8",
+  "description": "Node-native CLI for analyzing and changing TypeScript and JavaScript workspaces.",
   "publishConfig": {
     "access": "public"
   },
@@ -10,31 +10,28 @@
   },
   "files": [
     "dist",
-    "extension",
+    "config",
     "scripts/install-windows-launcher.cjs",
     "scripts/postinstall.cjs",
     "scripts/provision-runtime.cjs",
-    "runtimes/launcher",
+    "runtimes/tools",
     "README.md",
     "package.json"
   ],
   "scripts": {
-    "build": "tsc -p . && node scripts/copy-managed-host-assets.cjs",
-    "build:package": "node ../../scripts/package/clean-paths.cjs dist && tsc -p tsconfig.package.json && node scripts/copy-managed-host-assets.cjs && node ../../scripts/package/minify-js.cjs dist",
+    "build": "npm --silent --prefix ../tooling run build && tsc -p . && node scripts/copy-help-assets.cjs && node ../tooling/dist/cli.js packaging copy-control-plane-worker",
+    "build:package": "npm --silent --prefix ../tooling run build && node ../tooling/dist/cli.js packaging clean-paths dist && tsc -p tsconfig.package.json && node scripts/copy-help-assets.cjs && node ../tooling/dist/cli.js packaging copy-control-plane-worker --minify && node ../tooling/dist/cli.js packaging minify-js dist",
     "typecheck": "tsc -p . --noEmit",
     "postinstall": "node scripts/postinstall.cjs",
-    "prepack": "npm run build:package && node scripts/copy-extension-vsix.cjs",
+    "sync:tool-runtimes": "npm --silent --prefix ../tooling run build && node ../tooling/dist/cli.js runtime sync-tool-runtimes",
+    "prepack": "npm run build:package",
     "pack:local": "npm pack --pack-destination ../../.tmp"
   },
   "dependencies": {
     "typescript": "^6.0.3",
-    "ws": "^8.20.0",
     "zod": "^4.1.12"
   },
   "engines": {
     "node": ">=20"
-  },
-  "devDependencies": {
-    "@types/ws": "^8.18.1"
   }
 }

package/runtimes/tools/rg/manifest.json

@@ -0,0 +1,36 @@
+{
+  "schema": 1,
+  "tool": "rg",
+  "version": "15.1.0",
+  "source": {
+    "repo": "BurntSushi/ripgrep",
+    "tag": "15.1.0"
+  },
+  "platforms": {
+    "win32-x64": {
+      "asset": "ripgrep-15.1.0-x86_64-pc-windows-msvc.zip",
+      "sha256": "124510b94b6baa3380d051fdf4650eaa80a302c876d611e9dba0b2e18d87493a",
+      "executable": "rg.exe"
+    },
+    "linux-x64": {
+      "asset": "ripgrep-15.1.0-x86_64-unknown-linux-musl.tar.gz",
+      "sha256": "1c9297be4a084eea7ecaedf93eb03d058d6faae29bbc57ecdaf5063921491599",
+      "executable": "rg"
+    },
+    "linux-arm64": {
+      "asset": "ripgrep-15.1.0-aarch64-unknown-linux-gnu.tar.gz",
+      "sha256": "2b661c6ef508e902f388e9098d9c4c5aca72c87b55922d94abdba830b4dc885e",
+      "executable": "rg"
+    },
+    "darwin-x64": {
+      "asset": "ripgrep-15.1.0-x86_64-apple-darwin.tar.gz",
+      "sha256": "64811cb24e77cac3057d6c40b63ac9becf9082eedd54ca411b475b755d334882",
+      "executable": "rg"
+    },
+    "darwin-arm64": {
+      "asset": "ripgrep-15.1.0-aarch64-apple-darwin.tar.gz",
+      "sha256": "378e973289176ca0c6054054ee7f631a065874a352bf43f0fa60ef079b6ba715",
+      "executable": "rg"
+    }
+  }
+}

package/runtimes/tools/rtk/manifest.json

@@ -0,0 +1,36 @@
+{
+  "schema": 1,
+  "tool": "rtk",
+  "version": "0.42.3",
+  "source": {
+    "repo": "rtk-ai/rtk",
+    "tag": "v0.42.3"
+  },
+  "platforms": {
+    "win32-x64": {
+      "asset": "rtk-x86_64-pc-windows-msvc.zip",
+      "sha256": "334d05a6662576a84a78b771aee0749202eacabd87acbb9fd266e6a5466f700a",
+      "executable": "rtk.exe"
+    },
+    "linux-x64": {
+      "asset": "rtk-x86_64-unknown-linux-musl.tar.gz",
+      "sha256": "5df764a633709cb85d248258d085d24ec95faa8bca0e6835a93cd57cadc4eb9e",
+      "executable": "rtk"
+    },
+    "linux-arm64": {
+      "asset": "rtk-aarch64-unknown-linux-gnu.tar.gz",
+      "sha256": "2b7fa09d06f8dbf334c55482fad2e7ce4a1f8564bc9ed1f65d9f5992db8e5527",
+      "executable": "rtk"
+    },
+    "darwin-x64": {
+      "asset": "rtk-x86_64-apple-darwin.tar.gz",
+      "sha256": "7c72d05cfc71b7e2f20755b3754b728acecc7c0b1fbbb08757828f9e7bedd81a",
+      "executable": "rtk"
+    },
+    "darwin-arm64": {
+      "asset": "rtk-aarch64-apple-darwin.tar.gz",
+      "sha256": "d47823afb25919e4e60838c5622e88ffa6536bc0b36a34a3f928bdccac40f614",
+      "executable": "rtk"
+    }
+  }
+}

package/scripts/postinstall.cjs

@@ -1,29 +1,29 @@
-#!/usr/bin/env node
-
-const path = require("node:path");
-const { spawnSync } = require("node:child_process");
-
-const packageRoot = path.resolve(__dirname, "..");
-
-runBestEffort(path.join(__dirname, "install-windows-launcher.cjs"));
-runBestEffort(path.join(__dirname, "provision-runtime.cjs"), [], { inheritOutput: process.env.AIB_POSTINSTALL_QUIET !== "1" });
-
-function runBestEffort(scriptPath, args = [], options = {}) {
-  const inheritOutput = options.inheritOutput === true;
-  const result = spawnSync(process.execPath, [scriptPath, ...args], {
-    cwd: packageRoot,
-    env: process.env,
-    encoding: "utf8",
-    stdio: inheritOutput ? ["ignore", "inherit", "inherit"] : ["ignore", "pipe", "pipe"],
-    windowsHide: true
-  });
-
-  if (result.status === 0) {
-    return;
-  }
-
-  if (process.env.AIB_POSTINSTALL_STRICT === "1") {
-    process.stderr.write(result?.stderr || result?.stdout || `postinstall helper failed: ${scriptPath}\n`);
-    process.exit(result.status ?? 1);
-  }
-}
+#!/usr/bin/env node
+
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const packageRoot = path.resolve(__dirname, "..");
+
+runBestEffort(path.join(__dirname, "provision-runtime.cjs"), ["--quiet"]);
+runBestEffort(path.join(__dirname, "install-windows-launcher.cjs"));
+
+function runBestEffort(scriptPath, args = [], options = {}) {
+  const inheritOutput = options.inheritOutput === true;
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    cwd: packageRoot,
+    env: process.env,
+    encoding: "utf8",
+    stdio: inheritOutput ? ["ignore", "inherit", "inherit"] : ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+
+  if (result.status === 0) {
+    return;
+  }
+
+  if (process.env.AIB_POSTINSTALL_STRICT === "1") {
+    process.stderr.write(result?.stderr || result?.stdout || `postinstall helper failed: ${scriptPath}\n`);
+    process.exit(result.status ?? 1);
+  }
+}