@nurix/nustack 0.10.0-dev.10

package/dist/lib/etna/manager.js

@@ -0,0 +1,43 @@
+import { detectPackageManager, installPackage } from "../package_manager.js";
+import { assertSafePackageName } from "../guards.js";
+import { updateBindingEtnaProfile } from "../local_store/bindings.js";
+import { serializeProfileForBinding } from "./profile.js";
+export function toolkitPackageName(profile) {
+    if (!profile.name.startsWith("@"))
+        return null;
+    try {
+        return assertSafePackageName(profile.name);
+    }
+    catch {
+        return null;
+    }
+}
+export async function installToolkit(store, bindingId, profile, cwd, deps = {}) {
+    const packageName = toolkitPackageName(profile);
+    let result;
+    if (!packageName) {
+        result = { ok: true, installed: false, skipped: true, reason: "device_level_toolkit" };
+    }
+    else {
+        const observed = deps.observe ? await deps.observe(profile, cwd) : { name: profile.name, version: null, installed: false };
+        if (observed.installed && observed.version === profile.version) {
+            result = { ok: true, installed: false, skipped: true, reason: "already_pinned" };
+        }
+        else {
+            const manager = deps.manager ?? detectPackageManager(cwd);
+            const install = deps.install ?? installPackage;
+            try {
+                await install(manager, packageName, cwd);
+                result = { ok: true, installed: true, skipped: false };
+            }
+            catch (error) {
+                result = { ok: false, installed: false, skipped: false, reason: error instanceof Error ? error.message : String(error) };
+            }
+        }
+    }
+    updateBindingEtnaProfile(store, bindingId, serializeProfileForBinding(profile));
+    return result;
+}
+export function verifyToolkit(profile, observed) {
+    return observed.installed && observed.name === profile.name && observed.version === profile.version;
+}

package/dist/lib/etna/profile.js

@@ -0,0 +1,41 @@
+import { getWorkspace } from "../nustack_client.js";
+export class ToolkitProfileUnavailableError extends Error {
+    workspaceId;
+    constructor(workspaceId) {
+        super("The Workspace summary did not project a Toolkit Profile pin — the owning server plan must expose it on GET /api/v2/workspaces/{workspaceId}.");
+        this.name = "ToolkitProfileUnavailableError";
+        this.workspaceId = workspaceId;
+    }
+}
+export async function fetchToolkitProfile(baseUrl, accessToken, workspaceId) {
+    const workspace = await getWorkspace(baseUrl, accessToken, workspaceId);
+    const toolkit = workspace.toolkit;
+    if (!toolkit || typeof toolkit.name !== "string" || typeof toolkit.version !== "string") {
+        throw new ToolkitProfileUnavailableError(workspaceId);
+    }
+    return {
+        name: toolkit.name,
+        version: toolkit.version,
+        rendererVersion: typeof toolkit.rendererVersion === "string" ? toolkit.rendererVersion : "",
+        placementMapVersion: typeof toolkit.placementMapVersion === "string" ? toolkit.placementMapVersion : "",
+        catalogVersionId: null,
+    };
+}
+export function toolkitProfileFromManifest(manifest) {
+    return {
+        name: manifest.toolkit.name,
+        version: manifest.toolkit.version,
+        rendererVersion: manifest.toolkit.rendererVersion,
+        placementMapVersion: "",
+        catalogVersionId: null,
+    };
+}
+export function serializeProfileForBinding(profile) {
+    return JSON.stringify({
+        name: profile.name,
+        version: profile.version,
+        rendererVersion: profile.rendererVersion,
+        placementMapVersion: profile.placementMapVersion,
+        catalogVersion: profile.catalogVersionId,
+    });
+}

package/dist/lib/etna/reconcile.js

@@ -0,0 +1,77 @@
+import { writeWorkspaceManifests, readWorkspaceManifests, diagnoseManifests, } from "../onboarding/manifest_writer.js";
+import { serializeProfileForBinding } from "./profile.js";
+import { updateBindingEtnaProfile } from "../local_store/bindings.js";
+export function parseRecordedToolkit(binding) {
+    if (!binding.etnaProfileJson)
+        return null;
+    try {
+        const p = JSON.parse(binding.etnaProfileJson);
+        if (typeof p.name !== "string" || typeof p.version !== "string")
+            return null;
+        return {
+            name: p.name,
+            version: p.version,
+            rendererVersion: typeof p.rendererVersion === "string" ? p.rendererVersion : "",
+            placementMapVersion: typeof p.placementMapVersion === "string" ? p.placementMapVersion : "",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function toolkitCompatibility(binding, cloud) {
+    const recorded = parseRecordedToolkit(binding);
+    if (!recorded || !cloud)
+        return { compatible: true, blocksWrites: false, reason: null };
+    if (recorded.name !== cloud.name) {
+        return { compatible: false, blocksWrites: true, reason: `toolkit name diverges (local ${recorded.name} vs cloud ${cloud.name})` };
+    }
+    if (recorded.version !== cloud.version) {
+        return { compatible: false, blocksWrites: true, reason: `toolkit version diverges (local ${recorded.version} vs cloud ${cloud.version})` };
+    }
+    if (cloud.rendererVersion && recorded.rendererVersion && recorded.rendererVersion !== cloud.rendererVersion) {
+        return { compatible: false, blocksWrites: true, reason: `renderer version diverges (local ${recorded.rendererVersion} vs cloud ${cloud.rendererVersion})` };
+    }
+    return { compatible: true, blocksWrites: false, reason: null };
+}
+export async function buildReconcilePlan(root, binding, cloud) {
+    const manifests = await readWorkspaceManifests(root);
+    const cloudId = { name: cloud.name, version: cloud.version };
+    const diagnosis = diagnoseManifests(cloudId, manifests.workspaceManifest?.toolkit ?? null, manifests.serviceToolkit);
+    const changes = [];
+    const workspace = manifests.workspaceManifest?.toolkit;
+    if (workspace) {
+        pushIf(changes, ".nustack/workspace.json", "toolkit.name", workspace.name, cloud.name);
+        pushIf(changes, ".nustack/workspace.json", "toolkit.version", workspace.version, cloud.version);
+        pushIf(changes, ".nustack/workspace.json", "toolkit.rendererVersion", workspace.rendererVersion, cloud.rendererVersion);
+        pushIf(changes, ".nustack/workspace.json", "toolkit.placementMapVersion", workspace.placementMapVersion, cloud.placementMapVersion);
+    }
+    const svc = manifests.serviceToolkit;
+    if (svc) {
+        pushIf(changes, "nustack.service.json", "toolkit.name", svc.name, cloud.name);
+        pushIf(changes, "nustack.service.json", "toolkit.version", svc.version, cloud.version);
+    }
+    const recorded = parseRecordedToolkit(binding);
+    if (recorded) {
+        pushIf(changes, "binding", "name", recorded.name, cloud.name);
+        pushIf(changes, "binding", "version", recorded.version, cloud.version);
+    }
+    return { diagnosis, changes, migrations: [], noOp: changes.length === 0 && diagnosis === "aligned" };
+}
+function pushIf(changes, file, field, from, to) {
+    if (from !== to)
+        changes.push({ file, field, from, to });
+}
+export async function applyReconcile(store, bindingId, root, identity, cloud) {
+    await writeWorkspaceManifests(root, {
+        workspaceId: identity.workspaceId,
+        organizationId: identity.organizationId,
+        toolkit: {
+            name: cloud.name,
+            version: cloud.version,
+            rendererVersion: cloud.rendererVersion,
+            placementMapVersion: cloud.placementMapVersion,
+        },
+    });
+    updateBindingEtnaProfile(store, bindingId, serializeProfileForBinding(cloud));
+}

package/dist/lib/filebeat_installer.js

@@ -0,0 +1,246 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { chmod, copyFile, mkdir, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { nustackDir } from "./nustack_store.js";
+const FILEBEAT_VERSION = process.env.NUSTACK_FILEBEAT_VERSION || "8.15.3";
+export function desiredFilebeatVersion() {
+    return FILEBEAT_VERSION;
+}
+export function filebeatDir() {
+    return path.join(nustackDir(), "filebeat");
+}
+export function filebeatBinPath() {
+    return path.join(filebeatDir(), process.platform === "win32" ? "filebeat.exe" : "filebeat");
+}
+export function inputsDir() {
+    return path.join(filebeatDir(), "inputs.d");
+}
+export function mainConfigPath() {
+    return path.join(filebeatDir(), "filebeat.yml");
+}
+function artifactArch() {
+    if (process.platform === "linux")
+        return process.arch === "arm64" ? "arm64" : "x86_64";
+    return process.arch === "arm64" ? "aarch64" : "x86_64";
+}
+function artifactOs() {
+    if (process.platform === "darwin")
+        return "darwin";
+    if (process.platform === "win32")
+        return "windows";
+    return "linux";
+}
+function resolveBundledBinary() {
+    const pkg = `@nurix/nustack-filebeat-${process.platform}-${process.arch}`;
+    try {
+        const require = createRequire(import.meta.url);
+        const bin = process.platform === "win32" ? "filebeat.exe" : "filebeat";
+        return require.resolve(`${pkg}/${bin}`);
+    }
+    catch {
+        return null;
+    }
+}
+async function verifyChecksum(archive, checksumUrl, fileName) {
+    const response = await fetch(checksumUrl, { signal: AbortSignal.timeout(30_000) });
+    if (!response.ok) {
+        throw new Error(`Filebeat checksum fetch failed: HTTP ${response.status} (${checksumUrl})`);
+    }
+    const published = (await response.text()).trim().split(/\s+/)[0]?.toLowerCase();
+    const actual = createHash("sha512").update(archive).digest("hex");
+    if (!published || published !== actual) {
+        throw new Error(`Filebeat checksum mismatch for ${fileName} — refusing to install. Expected ${published}, got ${actual}.`);
+    }
+}
+async function downloadFilebeat(log) {
+    const ext = process.platform === "win32" ? "zip" : "tar.gz";
+    const stem = `filebeat-${FILEBEAT_VERSION}-${artifactOs()}-${artifactArch()}`;
+    const url = `https://artifacts.elastic.co/downloads/beats/filebeat/${stem}.${ext}`;
+    const tmp = path.join(filebeatDir(), `.${stem}.${ext}`);
+    log(`Downloading Filebeat ${FILEBEAT_VERSION} (${artifactOs()}-${artifactArch()})`);
+    const response = await fetch(url, { signal: AbortSignal.timeout(120_000) });
+    if (!response.ok)
+        throw new Error(`Filebeat download failed: HTTP ${response.status} (${url})`);
+    const archive = Buffer.from(await response.arrayBuffer());
+    await verifyChecksum(archive, `${url}.sha512`, `${stem}.${ext}`);
+    await mkdir(filebeatDir(), { recursive: true });
+    await writeFile(tmp, archive);
+    execFileSync("tar", ["-xf", tmp, "-C", filebeatDir()], { stdio: "ignore" });
+    await rm(tmp, { force: true });
+    const extractedBin = path.join(filebeatDir(), stem, process.platform === "win32" ? "filebeat.exe" : "filebeat");
+    await copyFile(extractedBin, filebeatBinPath());
+    if (process.platform !== "win32")
+        await chmod(filebeatBinPath(), 0o755);
+    await rm(path.join(filebeatDir(), stem), { recursive: true, force: true });
+}
+export async function ensureFilebeatBinary(log) {
+    if (existsSync(filebeatBinPath()))
+        return;
+    await mkdir(filebeatDir(), { recursive: true });
+    const bundled = resolveBundledBinary();
+    if (bundled) {
+        log("Using bundled Filebeat binary");
+        await copyFile(bundled, filebeatBinPath());
+        if (process.platform !== "win32")
+            await chmod(filebeatBinPath(), 0o755);
+        return;
+    }
+    await downloadFilebeat(log);
+}
+export function observedFilebeatVersion() {
+    if (!existsSync(filebeatBinPath()))
+        return null;
+    try {
+        const out = execFileSync(filebeatBinPath(), ["version"], {
+            encoding: "utf8",
+            timeout: 10_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return /version\s+(\d+\.\d+\.\d+)/.exec(out)?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+const SERVICE_LABEL = "co.nurix.nustack.filebeat";
+function run(cmd, args) {
+    try {
+        execFileSync(cmd, args, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function filebeatArgs() {
+    return [
+        "-c",
+        mainConfigPath(),
+        "--path.home",
+        filebeatDir(),
+        "--path.config",
+        filebeatDir(),
+        "--path.data",
+        path.join(filebeatDir(), "data"),
+    ];
+}
+async function registerLaunchAgent() {
+    const plistPath = path.join(os.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+    const args = [filebeatBinPath(), ...filebeatArgs()]
+        .map((a) => `    <string>${a}</string>`)
+        .join("\n");
+    const logPath = path.join(filebeatDir(), "filebeat.log");
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${logPath}</string>
+  <key>StandardErrorPath</key><string>${logPath}</string>
+</dict>
+</plist>
+`;
+    await mkdir(path.dirname(plistPath), { recursive: true });
+    await writeFile(plistPath, plist, "utf8");
+    run("launchctl", ["unload", plistPath]);
+    return run("launchctl", ["load", "-w", plistPath]);
+}
+async function registerSystemdUser() {
+    const unitDir = path.join(os.homedir(), ".config", "systemd", "user");
+    const exec = [filebeatBinPath(), ...filebeatArgs()].join(" ");
+    const unit = `[Unit]
+Description=NuStack session telemetry (Filebeat)
+
+[Service]
+ExecStart=${exec}
+Restart=always
+
+[Install]
+WantedBy=default.target
+`;
+    await mkdir(unitDir, { recursive: true });
+    await writeFile(path.join(unitDir, "nustack-filebeat.service"), unit, "utf8");
+    run("systemctl", ["--user", "daemon-reload"]);
+    return run("systemctl", ["--user", "enable", "--now", "nustack-filebeat.service"]);
+}
+function registerScheduledTask() {
+    const tr = [filebeatBinPath(), ...filebeatArgs()].map((a) => `"${a}"`).join(" ");
+    return run("schtasks", ["/Create", "/TN", "NuStackFilebeat", "/TR", tr, "/SC", "ONLOGON", "/F"]);
+}
+export async function registerAndStartService() {
+    await mkdir(path.join(filebeatDir(), "data"), { recursive: true });
+    if (process.platform === "darwin")
+        return registerLaunchAgent();
+    if (process.platform === "linux")
+        return registerSystemdUser();
+    if (process.platform === "win32")
+        return registerScheduledTask();
+    return false;
+}
+export async function restartService() {
+    if (process.platform === "darwin")
+        return registerLaunchAgent();
+    if (process.platform === "linux")
+        return run("systemctl", ["--user", "restart", "nustack-filebeat.service"]);
+    if (process.platform === "win32") {
+        run("schtasks", ["/End", "/TN", "NuStackFilebeat"]);
+        return run("schtasks", ["/Run", "/TN", "NuStackFilebeat"]);
+    }
+    return false;
+}
+export function unregisterService() {
+    if (process.platform === "darwin") {
+        run("launchctl", [
+            "unload",
+            "-w",
+            path.join(os.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`),
+        ]);
+    }
+    else if (process.platform === "linux") {
+        run("systemctl", ["--user", "disable", "--now", "nustack-filebeat.service"]);
+    }
+    else if (process.platform === "win32") {
+        run("schtasks", ["/Delete", "/TN", "NuStackFilebeat", "/F"]);
+    }
+}
+export function probeServiceRegistered() {
+    if (process.platform === "darwin")
+        return run("launchctl", ["list", SERVICE_LABEL]);
+    if (process.platform === "linux")
+        return run("systemctl", ["--user", "is-active", "nustack-filebeat.service"]);
+    if (process.platform === "win32")
+        return run("schtasks", ["/Query", "/TN", "NuStackFilebeat"]);
+    return false;
+}
+export function testFilebeatConfig(ctx) {
+    if (!existsSync(filebeatBinPath()))
+        return { ok: false, output: "filebeat binary not installed" };
+    try {
+        const output = execFileSync(filebeatBinPath(), [
+            "test",
+            "config",
+            "-c",
+            ctx.mainConfigPath,
+            "--path.home",
+            filebeatDir(),
+            "--path.config",
+            ctx.configDir,
+            "--path.data",
+            path.join(filebeatDir(), "data"),
+        ], { encoding: "utf8", timeout: 15_000, stdio: ["ignore", "pipe", "pipe"] });
+        return { ok: true, output };
+    }
+    catch (error) {
+        return { ok: false, output: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/lib/git-sync/core/commit_range.js

@@ -0,0 +1,37 @@
+import { runGit } from "./git_runner.js";
+import { readHeadCommit, readSymbolicBranch } from "./repository.js";
+function firstParentChain(repo, head) {
+    const { stdout } = runGit(repo.repositoryRoot, ["rev-list", "--first-parent", head]);
+    return stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+export function resolveCommitRange(repo, input) {
+    const branch = readSymbolicBranch(repo);
+    if (branch === null)
+        return { kind: "branch_wait", reason: "detached_head" };
+    if (branch !== input.boundBranch)
+        return { kind: "branch_wait", reason: "other_branch" };
+    const head = readHeadCommit(repo);
+    if (head === null)
+        return { kind: "no_op" };
+    if (input.lastProcessedCommitId === null)
+        return { kind: "no_op" };
+    if (input.lastProcessedCommitId === head)
+        return { kind: "no_op" };
+    if (!firstParentChain(repo, head).includes(input.lastProcessedCommitId)) {
+        return { kind: "history_decision_required" };
+    }
+    const { stdout } = runGit(repo.repositoryRoot, [
+        "rev-list",
+        "--first-parent",
+        "--reverse",
+        `${input.lastProcessedCommitId}..${head}`,
+    ]);
+    const commitIds = stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    return { kind: "range", commitIds };
+}