@dbx-tools/cli-service 0.9.36

package/lib/src/_host.js

@@ -0,0 +1,221 @@
+import { spawn } from "node:child_process";
+import { closeSync, openSync } from "node:fs";
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import * as systrayModule from "systray2";
+import { readServiceDefinition } from "./_config.js";
+import { closeServiceControl, listenForServiceControl, } from "./_control.js";
+import { defaultRuntimeContext, resolveServicePaths } from "./_paths.js";
+const CHILD_STOP_TIMEOUT_MILLISECONDS = 5_000;
+const SysTray = systrayConstructor();
+function systrayConstructor() {
+    const loaded = systrayModule.default;
+    if (typeof loaded === "function")
+        return loaded;
+    const nested = loaded && typeof loaded === "object" ? loaded.default : undefined;
+    if (typeof nested === "function")
+        return nested;
+    throw new TypeError("systray2 did not provide a constructor");
+}
+class CliServiceHost {
+    definition;
+    paths;
+    requestStop;
+    tray;
+    service;
+    control;
+    stopping = false;
+    constructor(definition, paths, requestStop) {
+        this.definition = definition;
+        this.paths = paths;
+        this.requestStop = requestStop;
+    }
+    async start() {
+        await mkdir(this.paths.directory, { recursive: true });
+        this.service = this.definition.command
+            ? this.startProcess(this.definition.command, true)
+            : undefined;
+        this.tray = this.createTray();
+        await this.tray.ready();
+        this.tray.onError((error) => {
+            void logError(this.paths.hostLog, error);
+            this.requestStop();
+        });
+        this.tray.onExit((code, signal) => {
+            if (this.stopping)
+                return;
+            void logMessage(this.paths.hostLog, `system tray exited (${signal ?? String(code)})`);
+            this.requestStop();
+        });
+        await this.tray.onClick((action) => {
+            const item = action.item;
+            item.click?.();
+        });
+        this.control = await listenForServiceControl(this.paths.controlAddress, () => this.status(), this.requestStop);
+    }
+    async stop() {
+        if (this.stopping)
+            return;
+        this.stopping = true;
+        if (this.control) {
+            await closeServiceControl(this.control, this.paths.controlAddress);
+            this.control = undefined;
+        }
+        if (this.tray) {
+            if (this.tray.process.exitCode === null && this.tray.process.signalCode === null) {
+                await this.tray.kill(false);
+            }
+            this.tray = undefined;
+        }
+        if (this.service) {
+            await stopProcess(this.service);
+            this.service = undefined;
+        }
+    }
+    status() {
+        return {
+            running: true,
+            pid: process.pid,
+            ...(this.service?.pid ? { servicePid: this.service.pid } : {}),
+        };
+    }
+    startProcess(command, managed) {
+        if (!command.executable) {
+            throw new Error("installed service commands require an executable");
+        }
+        const logDescriptor = openSync(this.paths.processLog, "a");
+        const child = spawn(command.executable, command.arguments ?? [], {
+            cwd: command.cwd,
+            env: { ...process.env, ...command.environment },
+            stdio: ["ignore", logDescriptor, logDescriptor],
+        });
+        closeSync(logDescriptor);
+        child.once("error", (error) => {
+            void logError(this.paths.hostLog, error);
+            if (managed)
+                this.requestStop();
+        });
+        child.once("exit", (code, signal) => {
+            if (!this.stopping && managed) {
+                void logMessage(this.paths.hostLog, `managed service exited (${signal ?? String(code)})`);
+                this.requestStop();
+            }
+        });
+        return child;
+    }
+    createTray() {
+        return new SysTray({
+            menu: {
+                icon: this.definition.icon,
+                title: "",
+                tooltip: `${this.definition.name} ${this.definition.version}`,
+                items: this.menuItems(),
+                isTemplateIcon: this.definition.isTemplateIcon,
+            },
+            debug: false,
+            copyDir: false,
+        });
+    }
+    menuItems() {
+        const custom = (this.definition.menu ?? []).map((item) => this.menuItem(item));
+        return [
+            {
+                title: `${this.definition.name} - ${this.definition.version}`,
+                tooltip: "",
+                enabled: false,
+            },
+            ...custom,
+            { ...SysTray.separator },
+            {
+                title: "Quit",
+                tooltip: `Stop ${this.definition.name}`,
+                click: this.requestStop,
+            },
+        ];
+    }
+    menuItem(item) {
+        if (item.type === "separator")
+            return { ...SysTray.separator };
+        if (item.type === "url") {
+            return {
+                title: item.label,
+                tooltip: item.url,
+                click: () => {
+                    this.openUrl(item.url);
+                },
+            };
+        }
+        return {
+            title: item.label,
+            tooltip: "",
+            click: () => {
+                const child = this.startProcess(item.command, false);
+                child.unref();
+            },
+        };
+    }
+    openUrl(url) {
+        const command = process.platform === "darwin"
+            ? { executable: "open", arguments: [url] }
+            : process.platform === "win32"
+                ? {
+                    executable: "rundll32.exe",
+                    arguments: ["url.dll,FileProtocolHandler", url],
+                }
+                : { executable: "xdg-open", arguments: [url] };
+        const child = this.startProcess(command, false);
+        child.unref();
+    }
+}
+async function runCliServiceHost(configFile) {
+    process.chdir(dirname(process.execPath));
+    const definition = await readServiceDefinition(configFile);
+    const runtime = defaultRuntimeContext();
+    const paths = resolveServicePaths(definition, runtime);
+    let requestStop = () => { };
+    const stopped = new Promise((resolve) => {
+        requestStop = resolve;
+    });
+    const host = new CliServiceHost(definition, paths, requestStop);
+    process.once("SIGINT", requestStop);
+    process.once("SIGTERM", requestStop);
+    try {
+        await host.start();
+        await stopped;
+    }
+    finally {
+        await host.stop();
+    }
+}
+async function stopProcess(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const exited = new Promise((resolve) => child.once("exit", () => resolve()));
+    child.kill("SIGTERM");
+    const timedOut = new Promise((resolve) => {
+        setTimeout(() => resolve("timeout"), CHILD_STOP_TIMEOUT_MILLISECONDS);
+    });
+    if ((await Promise.race([exited, timedOut])) === "timeout") {
+        child.kill("SIGKILL");
+        await exited;
+    }
+}
+async function logError(path, error) {
+    await logMessage(path, error instanceof Error ? (error.stack ?? error.message) : String(error));
+}
+async function logMessage(path, message) {
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, `${new Date().toISOString()} ${message}\n`, "utf8");
+}
+function argumentValue(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : undefined;
+}
+const configFile = argumentValue("--service-config");
+if (configFile) {
+    void runCliServiceHost(configFile).catch(async (error) => {
+        await logError(join(dirname(configFile), "host.log"), error);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_host.js","sourceRoot":"","sources":["../../src/_host.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawn, type ChildProcess } from \"node:child_process\";\nimport { closeSync, openSync } from \"node:fs\";\nimport { appendFile, mkdir } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\n\nimport * as systrayModule from \"systray2\";\nimport type SysTrayType from \"systray2\";\nimport type { MenuItem } from \"systray2\";\n\nimport { readServiceDefinition } from \"./_config.ts\";\nimport {\n  closeServiceControl,\n  listenForServiceControl,\n  type ServiceControlResponse,\n} from \"./_control.ts\";\nimport { defaultRuntimeContext, resolveServicePaths, type ServicePaths } from \"./_paths.ts\";\nimport type { CliServiceCommand, CliServiceDefinition, CliServiceMenuItem } from \"./definition.ts\";\n\nconst CHILD_STOP_TIMEOUT_MILLISECONDS = 5_000;\nconst SysTray = systrayConstructor();\n\ninterface ActionMenuItem extends MenuItem {\n  readonly click?: () => void;\n}\n\nfunction systrayConstructor(): typeof SysTrayType {\n  const loaded: unknown = systrayModule.default;\n  if (typeof loaded === \"function\") return loaded as typeof SysTrayType;\n  const nested =\n    loaded && typeof loaded === \"object\" ? (loaded as { default?: unknown }).default : undefined;\n  if (typeof nested === \"function\") return nested as typeof SysTrayType;\n  throw new TypeError(\"systray2 did not provide a constructor\");\n}\n\nclass CliServiceHost {\n  private readonly definition: CliServiceDefinition;\n  private readonly paths: ServicePaths;\n  private readonly requestStop: () => void;\n  private tray?: SysTrayType;\n  private service?: ChildProcess;\n  private control?: Awaited<ReturnType<typeof listenForServiceControl>>;\n  private stopping = false;\n\n  constructor(definition: CliServiceDefinition, paths: ServicePaths, requestStop: () => void) {\n    this.definition = definition;\n    this.paths = paths;\n    this.requestStop = requestStop;\n  }\n\n  async start(): Promise<void> {\n    await mkdir(this.paths.directory, { recursive: true });\n    this.service = this.definition.command\n      ? this.startProcess(this.definition.command, true)\n      : undefined;\n    this.tray = this.createTray();\n    await this.tray.ready();\n    this.tray.onError((error) => {\n      void logError(this.paths.hostLog, error);\n      this.requestStop();\n    });\n    this.tray.onExit((code, signal) => {\n      if (this.stopping) return;\n      void logMessage(this.paths.hostLog, `system tray exited (${signal ?? String(code)})`);\n      this.requestStop();\n    });\n    await this.tray.onClick((action) => {\n      const item = action.item as ActionMenuItem;\n      item.click?.();\n    });\n    this.control = await listenForServiceControl(\n      this.paths.controlAddress,\n      () => this.status(),\n      this.requestStop,\n    );\n  }\n\n  async stop(): Promise<void> {\n    if (this.stopping) return;\n    this.stopping = true;\n    if (this.control) {\n      await closeServiceControl(this.control, this.paths.controlAddress);\n      this.control = undefined;\n    }\n    if (this.tray) {\n      if (this.tray.process.exitCode === null && this.tray.process.signalCode === null) {\n        await this.tray.kill(false);\n      }\n      this.tray = undefined;\n    }\n    if (this.service) {\n      await stopProcess(this.service);\n      this.service = undefined;\n    }\n  }\n\n  private status(): ServiceControlResponse {\n    return {\n      running: true,\n      pid: process.pid,\n      ...(this.service?.pid ? { servicePid: this.service.pid } : {}),\n    };\n  }\n\n  private startProcess(command: CliServiceCommand, managed: boolean): ChildProcess {\n    if (!command.executable) {\n      throw new Error(\"installed service commands require an executable\");\n    }\n    const logDescriptor = openSync(this.paths.processLog, \"a\");\n    const child = spawn(command.executable, command.arguments ?? [], {\n      cwd: command.cwd,\n      env: { ...process.env, ...command.environment },\n      stdio: [\"ignore\", logDescriptor, logDescriptor],\n    });\n    closeSync(logDescriptor);\n    child.once(\"error\", (error) => {\n      void logError(this.paths.hostLog, error);\n      if (managed) this.requestStop();\n    });\n    child.once(\"exit\", (code, signal) => {\n      if (!this.stopping && managed) {\n        void logMessage(this.paths.hostLog, `managed service exited (${signal ?? String(code)})`);\n        this.requestStop();\n      }\n    });\n    return child;\n  }\n\n  private createTray(): SysTrayType {\n    return new SysTray({\n      menu: {\n        icon: this.definition.icon,\n        title: \"\",\n        tooltip: `${this.definition.name} ${this.definition.version}`,\n        items: this.menuItems(),\n        isTemplateIcon: this.definition.isTemplateIcon,\n      },\n      debug: false,\n      copyDir: false,\n    });\n  }\n\n  private menuItems(): ActionMenuItem[] {\n    const custom = (this.definition.menu ?? []).map((item) => this.menuItem(item));\n    return [\n      {\n        title: `${this.definition.name} - ${this.definition.version}`,\n        tooltip: \"\",\n        enabled: false,\n      },\n      ...custom,\n      { ...SysTray.separator },\n      {\n        title: \"Quit\",\n        tooltip: `Stop ${this.definition.name}`,\n        click: this.requestStop,\n      },\n    ];\n  }\n\n  private menuItem(item: CliServiceMenuItem): ActionMenuItem {\n    if (item.type === \"separator\") return { ...SysTray.separator };\n    if (item.type === \"url\") {\n      return {\n        title: item.label,\n        tooltip: item.url,\n        click: () => {\n          this.openUrl(item.url);\n        },\n      };\n    }\n    return {\n      title: item.label,\n      tooltip: \"\",\n      click: () => {\n        const child = this.startProcess(item.command, false);\n        child.unref();\n      },\n    };\n  }\n\n  private openUrl(url: string): void {\n    const command =\n      process.platform === \"darwin\"\n        ? { executable: \"open\", arguments: [url] }\n        : process.platform === \"win32\"\n          ? {\n              executable: \"rundll32.exe\",\n              arguments: [\"url.dll,FileProtocolHandler\", url],\n            }\n          : { executable: \"xdg-open\", arguments: [url] };\n    const child = this.startProcess(command, false);\n    child.unref();\n  }\n}\n\nasync function runCliServiceHost(configFile: string): Promise<void> {\n  process.chdir(dirname(process.execPath));\n  const definition = await readServiceDefinition(configFile);\n  const runtime = defaultRuntimeContext();\n  const paths = resolveServicePaths(definition, runtime);\n  let requestStop: () => void = () => {};\n  const stopped = new Promise<void>((resolve) => {\n    requestStop = resolve;\n  });\n  const host = new CliServiceHost(definition, paths, requestStop);\n  process.once(\"SIGINT\", requestStop);\n  process.once(\"SIGTERM\", requestStop);\n  try {\n    await host.start();\n    await stopped;\n  } finally {\n    await host.stop();\n  }\n}\n\nasync function stopProcess(child: ChildProcess): Promise<void> {\n  if (child.exitCode !== null || child.signalCode !== null) return;\n  const exited = new Promise<void>((resolve) => child.once(\"exit\", () => resolve()));\n  child.kill(\"SIGTERM\");\n  const timedOut = new Promise<\"timeout\">((resolve) => {\n    setTimeout(() => resolve(\"timeout\"), CHILD_STOP_TIMEOUT_MILLISECONDS);\n  });\n  if ((await Promise.race([exited, timedOut])) === \"timeout\") {\n    child.kill(\"SIGKILL\");\n    await exited;\n  }\n}\n\nasync function logError(path: string, error: unknown): Promise<void> {\n  await logMessage(path, error instanceof Error ? (error.stack ?? error.message) : String(error));\n}\n\nasync function logMessage(path: string, message: string): Promise<void> {\n  await mkdir(dirname(path), { recursive: true });\n  await appendFile(path, `${new Date().toISOString()} ${message}\\n`, \"utf8\");\n}\n\nfunction argumentValue(name: string): string | undefined {\n  const index = process.argv.indexOf(name);\n  return index >= 0 ? process.argv[index + 1] : undefined;\n}\n\nconst configFile = argumentValue(\"--service-config\");\nif (configFile) {\n  void runCliServiceHost(configFile).catch(async (error: unknown) => {\n    await logError(join(dirname(configFile), \"host.log\"), error);\n    process.exitCode = 1;\n  });\n}\n"]}

package/lib/src/_package.d.ts

@@ -0,0 +1,12 @@
+export interface ServicePackage {
+    readonly directory: string;
+    readonly name: string;
+    readonly version: string;
+    bin(name?: string): string;
+    dependencies(): Readonly<Record<string, string>>;
+}
+export declare function resolveServicePackage(reference: string, cwd?: string): ServicePackage;
+export declare function servicePackageDefaults(pkg: ServicePackage): {
+    id: string;
+    name: string;
+};

package/lib/src/_package.js

@@ -0,0 +1,140 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as projectUtils from "@dbx-tools/core/project-utils";
+export function resolveServicePackage(reference, cwd = process.cwd()) {
+    const local = localManifest(reference);
+    if (local)
+        return servicePackage(local);
+    const name = reference;
+    const installed = installedManifest(name);
+    if (installed)
+        return servicePackage(installed, name);
+    const root = projectUtils.root(cwd);
+    if (!root)
+        throw new Error(`could not resolve package: ${name}`);
+    const manifest = readRecord(join(root, "package.json"));
+    const workspaces = Array.isArray(manifest.workspaces) ? manifest.workspaces : [];
+    for (const member of workspaces) {
+        if (typeof member !== "string" || /[*?[\]{}]/.test(member))
+            continue;
+        const path = join(root, member, "package.json");
+        if (!existsSync(path))
+            continue;
+        const candidate = readRecord(path);
+        if (candidate.name === name)
+            return servicePackage(path, name);
+    }
+    throw new Error(`could not resolve installed or workspace package: ${name}`);
+}
+export function servicePackageDefaults(pkg) {
+    const segments = pkg.name.replace(/^@/, "").split("/");
+    const rawName = segments.at(-1);
+    const rawScope = segments.length > 1 ? segments[0].split("-")[0] : "";
+    const name = rawName.replace(/^cli-/, "").replaceAll("-", " ");
+    return {
+        id: pkg.name
+            .replace(/^@/, "")
+            .replaceAll("/", ".")
+            .replace(/[^a-z0-9._-]+/gi, "-"),
+        name: [rawScope, name].filter(Boolean).join(" "),
+    };
+}
+function localManifest(reference) {
+    let path;
+    if (reference.startsWith("file:")) {
+        path = fileURLToPath(reference);
+    }
+    else if (isAbsolute(reference)) {
+        path = reference;
+    }
+    else {
+        return undefined;
+    }
+    let current = existsSync(path) ? dirname(path) : path;
+    while (true) {
+        const manifest = join(current, "package.json");
+        if (existsSync(manifest))
+            return manifest;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function installedManifest(name) {
+    try {
+        return createRequire(import.meta.url).resolve(`${name}/package.json`);
+    }
+    catch (error) {
+        if (error.code === "MODULE_NOT_FOUND")
+            return undefined;
+        throw error;
+    }
+}
+function servicePackage(manifestPath, expectedName) {
+    const manifest = readRecord(manifestPath);
+    if (typeof manifest.name !== "string" || !manifest.name) {
+        throw new Error(`package has no name: ${manifestPath}`);
+    }
+    if (expectedName && manifest.name !== expectedName) {
+        throw new Error(`resolved package name does not match ${expectedName}: ${manifestPath}`);
+    }
+    if (typeof manifest.version !== "string" || !manifest.version) {
+        throw new Error(`package has no version: ${manifestPath}`);
+    }
+    const directory = dirname(manifestPath);
+    return {
+        directory,
+        name: manifest.name,
+        version: manifest.version,
+        bin(name) {
+            return resolveBin(directory, manifest.bin, name);
+        },
+        dependencies() {
+            const dependencies = isRecord(manifest.dependencies)
+                ? Object.keys(manifest.dependencies)
+                : [];
+            const require = createRequire(manifestPath);
+            return Object.fromEntries(dependencies.map((dependency) => {
+                const path = require.resolve(`${dependency}/package.json`);
+                const resolved = readRecord(path);
+                if (typeof resolved.version !== "string" || !resolved.version) {
+                    throw new Error(`dependency has no version: ${path}`);
+                }
+                return [dependency, resolved.version];
+            }));
+        },
+    };
+}
+function resolveBin(directory, value, name) {
+    if (typeof value === "string") {
+        if (name)
+            throw new Error(`package exposes one unnamed bin, not ${name}`);
+        return resolve(directory, value);
+    }
+    if (!isRecord(value))
+        throw new Error("package has no bin");
+    if (name) {
+        const target = value[name];
+        if (typeof target !== "string")
+            throw new Error(`package has no bin named ${name}`);
+        return resolve(directory, target);
+    }
+    const targets = Object.values(value).filter((target) => typeof target === "string");
+    if (targets.length !== 1) {
+        throw new Error("package has multiple bins; command.binName is required");
+    }
+    return resolve(directory, targets[0]);
+}
+function readRecord(path) {
+    const value = JSON.parse(readFileSync(path, "utf8"));
+    if (!isRecord(value))
+        throw new Error(`package manifest is not an object: ${path}`);
+    return value;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_package.js","sourceRoot":"","sources":["../../src/_package.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,KAAK,YAAY,MAAM,+BAA+B,CAAC;AAU9D,MAAM,UAAU,qBAAqB,CACnC,SAAiB,EACjB,MAAc,OAAO,CAAC,GAAG,EAAE;IAE3B,MAAM,KAAK,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;IACvC,IAAI,KAAK;QAAE,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC;IAExC,MAAM,IAAI,GAAG,SAAS,CAAC;IACvB,MAAM,SAAS,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC1C,IAAI,SAAS;QAAE,OAAO,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAEtD,MAAM,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,8BAA8B,IAAI,EAAE,CAAC,CAAC;IACjE,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC;IACxD,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;IACjF,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE,CAAC;QAChC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC;YAAE,SAAS;QACrE,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC;QAChD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,SAAS;QAChC,MAAM,SAAS,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI;YAAE,OAAO,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACjE,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,qDAAqD,IAAI,EAAE,CAAC,CAAC;AAC/E,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,GAAmB;IAIxD,MAAM,QAAQ,GAAG,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACvD,MAAM,OAAO,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAE,CAAC;IACjC,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACxE,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC/D,OAAO;QACL,EAAE,EAAE,GAAG,CAAC,IAAI;aACT,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;aACjB,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC;aACpB,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC;QAClC,IAAI,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;KACjD,CAAC;AACJ,CAAC;AAED,SAAS,aAAa,CAAC,SAAiB;IACtC,IAAI,IAAY,CAAC;IACjB,IAAI,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAClC,IAAI,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;SAAM,IAAI,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QACjC,IAAI,GAAG,SAAS,CAAC;IACnB,CAAC;SAAM,CAAC;QACN,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACtD,OAAO,IAAI,EAAE,CAAC;QACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;QAC/C,IAAI,UAAU,CAAC,QAAQ,CAAC;YAAE,OAAO,QAAQ,CAAC;QAC1C,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAChC,IAAI,MAAM,KAAK,OAAO;YAAE,OAAO,SAAS,CAAC;QACzC,OAAO,GAAG,MAAM,CAAC;IACnB,CAAC;AACH,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAY;IACrC,IAAI,CAAC;QACH,OAAO,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,IAAI,eAAe,CAAC,CAAC;IACxE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAK,KAA+B,CAAC,IAAI,KAAK,kBAAkB;YAAE,OAAO,SAAS,CAAC;QACnF,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,YAAoB,EAAE,YAAqB;IACjE,MAAM,QAAQ,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;IAC1C,IAAI,OAAO,QAAQ,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,wBAAwB,YAAY,EAAE,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,YAAY,IAAI,QAAQ,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,wCAAwC,YAAY,KAAK,YAAY,EAAE,CAAC,CAAC;IAC3F,CAAC;IACD,IAAI,OAAO,QAAQ,CAAC,OAAO,KAAK,QAAQ,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;QAC9D,MAAM,IAAI,KAAK,CAAC,2BAA2B,YAAY,EAAE,CAAC,CAAC;IAC7D,CAAC;IACD,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACxC,OAAO;QACL,SAAS;QACT,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,OAAO,EAAE,QAAQ,CAAC,OAAO;QACzB,GAAG,CAAC,IAAI;YACN,OAAO,UAAU,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACnD,CAAC;QACD,YAAY;YACV,MAAM,YAAY,GAAG,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC;gBAClD,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC;gBACpC,CAAC,CAAC,EAAE,CAAC;YACP,MAAM,OAAO,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC;YAC5C,OAAO,MAAM,CAAC,WAAW,CACvB,YAAY,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE;gBAC9B,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,UAAU,eAAe,CAAC,CAAC;gBAC3D,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;gBAClC,IAAI,OAAO,QAAQ,CAAC,OAAO,KAAK,QAAQ,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;oBAC9D,MAAM,IAAI,KAAK,CAAC,8BAA8B,IAAI,EAAE,CAAC,CAAC;gBACxD,CAAC;gBACD,OAAO,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;YACxC,CAAC,CAAC,CACH,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AAED,SAAS,UAAU,CAAC,SAAiB,EAAE,KAAc,EAAE,IAAa;IAClE,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,IAAI,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,IAAI,EAAE,CAAC,CAAC;QAC1E,OAAO,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IACD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;IAC5D,IAAI,IAAI,EAAE,CAAC;QACT,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,OAAO,MAAM,KAAK,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,IAAI,EAAE,CAAC,CAAC;QACpF,OAAO,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACpC,CAAC;IACD,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CACzC,CAAC,MAAM,EAAoB,EAAE,CAAC,OAAO,MAAM,KAAK,QAAQ,CACzD,CAAC;IACF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAE,CAAC,CAAC;AACzC,CAAC;AAED,SAAS,UAAU,CAAC,IAAY;IAC9B,MAAM,KAAK,GAAY,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9D,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,IAAI,EAAE,CAAC,CAAC;IACpF,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC","sourcesContent":["import { existsSync, readFileSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport { dirname, isAbsolute, join, resolve } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\nimport * as projectUtils from \"@dbx-tools/core/project-utils\";\n\nexport interface ServicePackage {\n  readonly directory: string;\n  readonly name: string;\n  readonly version: string;\n  bin(name?: string): string;\n  dependencies(): Readonly<Record<string, string>>;\n}\n\nexport function resolveServicePackage(\n  reference: string,\n  cwd: string = process.cwd(),\n): ServicePackage {\n  const local = localManifest(reference);\n  if (local) return servicePackage(local);\n\n  const name = reference;\n  const installed = installedManifest(name);\n  if (installed) return servicePackage(installed, name);\n\n  const root = projectUtils.root(cwd);\n  if (!root) throw new Error(`could not resolve package: ${name}`);\n  const manifest = readRecord(join(root, \"package.json\"));\n  const workspaces = Array.isArray(manifest.workspaces) ? manifest.workspaces : [];\n  for (const member of workspaces) {\n    if (typeof member !== \"string\" || /[*?[\\]{}]/.test(member)) continue;\n    const path = join(root, member, \"package.json\");\n    if (!existsSync(path)) continue;\n    const candidate = readRecord(path);\n    if (candidate.name === name) return servicePackage(path, name);\n  }\n  throw new Error(`could not resolve installed or workspace package: ${name}`);\n}\n\nexport function servicePackageDefaults(pkg: ServicePackage): {\n  id: string;\n  name: string;\n} {\n  const segments = pkg.name.replace(/^@/, \"\").split(\"/\");\n  const rawName = segments.at(-1)!;\n  const rawScope = segments.length > 1 ? segments[0]!.split(\"-\")[0]! : \"\";\n  const name = rawName.replace(/^cli-/, \"\").replaceAll(\"-\", \" \");\n  return {\n    id: pkg.name\n      .replace(/^@/, \"\")\n      .replaceAll(\"/\", \".\")\n      .replace(/[^a-z0-9._-]+/gi, \"-\"),\n    name: [rawScope, name].filter(Boolean).join(\" \"),\n  };\n}\n\nfunction localManifest(reference: string): string | undefined {\n  let path: string;\n  if (reference.startsWith(\"file:\")) {\n    path = fileURLToPath(reference);\n  } else if (isAbsolute(reference)) {\n    path = reference;\n  } else {\n    return undefined;\n  }\n  let current = existsSync(path) ? dirname(path) : path;\n  while (true) {\n    const manifest = join(current, \"package.json\");\n    if (existsSync(manifest)) return manifest;\n    const parent = dirname(current);\n    if (parent === current) return undefined;\n    current = parent;\n  }\n}\n\nfunction installedManifest(name: string): string | undefined {\n  try {\n    return createRequire(import.meta.url).resolve(`${name}/package.json`);\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === \"MODULE_NOT_FOUND\") return undefined;\n    throw error;\n  }\n}\n\nfunction servicePackage(manifestPath: string, expectedName?: string): ServicePackage {\n  const manifest = readRecord(manifestPath);\n  if (typeof manifest.name !== \"string\" || !manifest.name) {\n    throw new Error(`package has no name: ${manifestPath}`);\n  }\n  if (expectedName && manifest.name !== expectedName) {\n    throw new Error(`resolved package name does not match ${expectedName}: ${manifestPath}`);\n  }\n  if (typeof manifest.version !== \"string\" || !manifest.version) {\n    throw new Error(`package has no version: ${manifestPath}`);\n  }\n  const directory = dirname(manifestPath);\n  return {\n    directory,\n    name: manifest.name,\n    version: manifest.version,\n    bin(name) {\n      return resolveBin(directory, manifest.bin, name);\n    },\n    dependencies() {\n      const dependencies = isRecord(manifest.dependencies)\n        ? Object.keys(manifest.dependencies)\n        : [];\n      const require = createRequire(manifestPath);\n      return Object.fromEntries(\n        dependencies.map((dependency) => {\n          const path = require.resolve(`${dependency}/package.json`);\n          const resolved = readRecord(path);\n          if (typeof resolved.version !== \"string\" || !resolved.version) {\n            throw new Error(`dependency has no version: ${path}`);\n          }\n          return [dependency, resolved.version];\n        }),\n      );\n    },\n  };\n}\n\nfunction resolveBin(directory: string, value: unknown, name?: string): string {\n  if (typeof value === \"string\") {\n    if (name) throw new Error(`package exposes one unnamed bin, not ${name}`);\n    return resolve(directory, value);\n  }\n  if (!isRecord(value)) throw new Error(\"package has no bin\");\n  if (name) {\n    const target = value[name];\n    if (typeof target !== \"string\") throw new Error(`package has no bin named ${name}`);\n    return resolve(directory, target);\n  }\n  const targets = Object.values(value).filter(\n    (target): target is string => typeof target === \"string\",\n  );\n  if (targets.length !== 1) {\n    throw new Error(\"package has multiple bins; command.binName is required\");\n  }\n  return resolve(directory, targets[0]!);\n}\n\nfunction readRecord(path: string): Record<string, unknown> {\n  const value: unknown = JSON.parse(readFileSync(path, \"utf8\"));\n  if (!isRecord(value)) throw new Error(`package manifest is not an object: ${path}`);\n  return value;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n"]}

package/lib/src/_paths.d.ts

@@ -0,0 +1,17 @@
+import type { CliServiceDefinition } from "./definition.ts";
+export interface ServiceRuntimeContext {
+    readonly platform: NodeJS.Platform;
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly homeDirectory: string;
+    readonly temporaryDirectory: string;
+}
+export interface ServicePaths {
+    readonly directory: string;
+    readonly configFile: string;
+    readonly hostLog: string;
+    readonly processLog: string;
+    readonly controlAddress: string;
+    readonly startupFile: string;
+}
+export declare function defaultRuntimeContext(): ServiceRuntimeContext;
+export declare function resolveServicePaths(definition: CliServiceDefinition, runtime: ServiceRuntimeContext): ServicePaths;

package/lib/src/_paths.js

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+import { homedir, tmpdir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+export function defaultRuntimeContext() {
+    return {
+        platform: process.platform,
+        environment: process.env,
+        homeDirectory: homedir(),
+        temporaryDirectory: tmpdir(),
+    };
+}
+export function resolveServicePaths(definition, runtime) {
+    const directory = definition.dataDirectory
+        ? resolve(definition.dataDirectory)
+        : join(configurationRoot(runtime), definition.id);
+    return {
+        directory,
+        configFile: join(directory, "service.json"),
+        hostLog: join(directory, "host.log"),
+        processLog: join(directory, "service.log"),
+        controlAddress: controlAddress(definition.id, runtime),
+        startupFile: startupFile(definition.id, runtime),
+    };
+}
+function configurationRoot(runtime) {
+    if (runtime.platform === "darwin") {
+        return join(runtime.homeDirectory, "Library", "Application Support");
+    }
+    if (runtime.platform === "win32") {
+        return resolveEnvironmentPath(runtime.environment.APPDATA, join(runtime.homeDirectory, "AppData", "Roaming"));
+    }
+    return resolveEnvironmentPath(runtime.environment.XDG_CONFIG_HOME, join(runtime.homeDirectory, ".config"));
+}
+function controlAddress(id, runtime) {
+    const token = createHash("sha256").update(id).digest("hex").slice(0, 16);
+    if (runtime.platform === "win32") {
+        return `\\\\.\\pipe\\dbx-tools-cli-service-${token}`;
+    }
+    return join(runtime.temporaryDirectory, `dbx-tools-cli-service-${token}.sock`);
+}
+function startupFile(id, runtime) {
+    if (runtime.platform === "darwin") {
+        return join(runtime.homeDirectory, "Library", "LaunchAgents", `${id}.plist`);
+    }
+    if (runtime.platform === "win32") {
+        return join(resolveEnvironmentPath(runtime.environment.APPDATA, join(runtime.homeDirectory, "AppData", "Roaming")), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", `${id}.cmd`);
+    }
+    return join(resolveEnvironmentPath(runtime.environment.XDG_CONFIG_HOME, join(runtime.homeDirectory, ".config")), "autostart", `${id}.desktop`);
+}
+function resolveEnvironmentPath(value, fallback) {
+    if (!value)
+        return fallback;
+    return isAbsolute(value) ? value : resolve(value);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX3BhdGhzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL19wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzFDLE9BQU8sRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxNQUFNLFdBQVcsQ0FBQztBQW9CdEQsTUFBTSxVQUFVLHFCQUFxQjtJQUNuQyxPQUFPO1FBQ0wsUUFBUSxFQUFFLE9BQU8sQ0FBQyxRQUFRO1FBQzFCLFdBQVcsRUFBRSxPQUFPLENBQUMsR0FBRztRQUN4QixhQUFhLEVBQUUsT0FBTyxFQUFFO1FBQ3hCLGtCQUFrQixFQUFFLE1BQU0sRUFBRTtLQUM3QixDQUFDO0FBQ0osQ0FBQztBQUVELE1BQU0sVUFBVSxtQkFBbUIsQ0FDakMsVUFBZ0MsRUFDaEMsT0FBOEI7SUFFOUIsTUFBTSxTQUFTLEdBQUcsVUFBVSxDQUFDLGFBQWE7UUFDeEMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDO1FBQ25DLENBQUMsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsT0FBTyxDQUFDLEVBQUUsVUFBVSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3BELE9BQU87UUFDTCxTQUFTO1FBQ1QsVUFBVSxFQUFFLElBQUksQ0FBQyxTQUFTLEVBQUUsY0FBYyxDQUFDO1FBQzNDLE9BQU8sRUFBRSxJQUFJLENBQUMsU0FBUyxFQUFFLFVBQVUsQ0FBQztRQUNwQyxVQUFVLEVBQUUsSUFBSSxDQUFDLFNBQVMsRUFBRSxhQUFhLENBQUM7UUFDMUMsY0FBYyxFQUFFLGNBQWMsQ0FBQyxVQUFVLENBQUMsRUFBRSxFQUFFLE9BQU8sQ0FBQztRQUN0RCxXQUFXLEVBQUUsV0FBVyxDQUFDLFVBQVUsQ0FBQyxFQUFFLEVBQUUsT0FBTyxDQUFDO0tBQ2pELENBQUM7QUFDSixDQUFDO0FBRUQsU0FBUyxpQkFBaUIsQ0FBQyxPQUE4QjtJQUN2RCxJQUFJLE9BQU8sQ0FBQyxRQUFRLEtBQUssUUFBUSxFQUFFLENBQUM7UUFDbEMsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSxTQUFTLEVBQUUscUJBQXFCLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBQ0QsSUFBSSxPQUFPLENBQUMsUUFBUSxLQUFLLE9BQU8sRUFBRSxDQUFDO1FBQ2pDLE9BQU8sc0JBQXNCLENBQzNCLE9BQU8sQ0FBQyxXQUFXLENBQUMsT0FBTyxFQUMzQixJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSxTQUFTLEVBQUUsU0FBUyxDQUFDLENBQ2xELENBQUM7SUFDSixDQUFDO0lBQ0QsT0FBTyxzQkFBc0IsQ0FDM0IsT0FBTyxDQUFDLFdBQVcsQ0FBQyxlQUFlLEVBQ25DLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxFQUFFLFNBQVMsQ0FBQyxDQUN2QyxDQUFDO0FBQ0osQ0FBQztBQUVELFNBQVMsY0FBYyxDQUFDLEVBQVUsRUFBRSxPQUE4QjtJQUNoRSxNQUFNLEtBQUssR0FBRyxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ3pFLElBQUksT0FBTyxDQUFDLFFBQVEsS0FBSyxPQUFPLEVBQUUsQ0FBQztRQUNqQyxPQUFPLHNDQUFzQyxLQUFLLEVBQUUsQ0FBQztJQUN2RCxDQUFDO0lBQ0QsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLGtCQUFrQixFQUFFLHlCQUF5QixLQUFLLE9BQU8sQ0FBQyxDQUFDO0FBQ2pGLENBQUM7QUFFRCxTQUFTLFdBQVcsQ0FBQyxFQUFVLEVBQUUsT0FBOEI7SUFDN0QsSUFBSSxPQUFPLENBQUMsUUFBUSxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQ2xDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLEVBQUUsU0FBUyxFQUFFLGNBQWMsRUFBRSxHQUFHLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDL0UsQ0FBQztJQUNELElBQUksT0FBTyxDQUFDLFFBQVEsS0FBSyxPQUFPLEVBQUUsQ0FBQztRQUNqQyxPQUFPLElBQUksQ0FDVCxzQkFBc0IsQ0FDcEIsT0FBTyxDQUFDLFdBQVcsQ0FBQyxPQUFPLEVBQzNCLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxFQUFFLFNBQVMsRUFBRSxTQUFTLENBQUMsQ0FDbEQsRUFDRCxXQUFXLEVBQ1gsU0FBUyxFQUNULFlBQVksRUFDWixVQUFVLEVBQ1YsU0FBUyxFQUNULEdBQUcsRUFBRSxNQUFNLENBQ1osQ0FBQztJQUNKLENBQUM7SUFDRCxPQUFPLElBQUksQ0FDVCxzQkFBc0IsQ0FDcEIsT0FBTyxDQUFDLFdBQVcsQ0FBQyxlQUFlLEVBQ25DLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxFQUFFLFNBQVMsQ0FBQyxDQUN2QyxFQUNELFdBQVcsRUFDWCxHQUFHLEVBQUUsVUFBVSxDQUNoQixDQUFDO0FBQ0osQ0FBQztBQUVELFNBQVMsc0JBQXNCLENBQUMsS0FBeUIsRUFBRSxRQUFnQjtJQUN6RSxJQUFJLENBQUMsS0FBSztRQUFFLE9BQU8sUUFBUSxDQUFDO0lBQzVCLE9BQU8sVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUNwRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlSGFzaCB9IGZyb20gXCJub2RlOmNyeXB0b1wiO1xuaW1wb3J0IHsgaG9tZWRpciwgdG1wZGlyIH0gZnJvbSBcIm5vZGU6b3NcIjtcbmltcG9ydCB7IGlzQWJzb2x1dGUsIGpvaW4sIHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5cbmltcG9ydCB0eXBlIHsgQ2xpU2VydmljZURlZmluaXRpb24gfSBmcm9tIFwiLi9kZWZpbml0aW9uLnRzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2VydmljZVJ1bnRpbWVDb250ZXh0IHtcbiAgcmVhZG9ubHkgcGxhdGZvcm06IE5vZGVKUy5QbGF0Zm9ybTtcbiAgcmVhZG9ubHkgZW52aXJvbm1lbnQ6IFJlYWRvbmx5PE5vZGVKUy5Qcm9jZXNzRW52PjtcbiAgcmVhZG9ubHkgaG9tZURpcmVjdG9yeTogc3RyaW5nO1xuICByZWFkb25seSB0ZW1wb3JhcnlEaXJlY3Rvcnk6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTZXJ2aWNlUGF0aHMge1xuICByZWFkb25seSBkaXJlY3Rvcnk6IHN0cmluZztcbiAgcmVhZG9ubHkgY29uZmlnRmlsZTogc3RyaW5nO1xuICByZWFkb25seSBob3N0TG9nOiBzdHJpbmc7XG4gIHJlYWRvbmx5IHByb2Nlc3NMb2c6IHN0cmluZztcbiAgcmVhZG9ubHkgY29udHJvbEFkZHJlc3M6IHN0cmluZztcbiAgcmVhZG9ubHkgc3RhcnR1cEZpbGU6IHN0cmluZztcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGRlZmF1bHRSdW50aW1lQ29udGV4dCgpOiBTZXJ2aWNlUnVudGltZUNvbnRleHQge1xuICByZXR1cm4ge1xuICAgIHBsYXRmb3JtOiBwcm9jZXNzLnBsYXRmb3JtLFxuICAgIGVudmlyb25tZW50OiBwcm9jZXNzLmVudixcbiAgICBob21lRGlyZWN0b3J5OiBob21lZGlyKCksXG4gICAgdGVtcG9yYXJ5RGlyZWN0b3J5OiB0bXBkaXIoKSxcbiAgfTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVTZXJ2aWNlUGF0aHMoXG4gIGRlZmluaXRpb246IENsaVNlcnZpY2VEZWZpbml0aW9uLFxuICBydW50aW1lOiBTZXJ2aWNlUnVudGltZUNvbnRleHQsXG4pOiBTZXJ2aWNlUGF0aHMge1xuICBjb25zdCBkaXJlY3RvcnkgPSBkZWZpbml0aW9uLmRhdGFEaXJlY3RvcnlcbiAgICA/IHJlc29sdmUoZGVmaW5pdGlvbi5kYXRhRGlyZWN0b3J5KVxuICAgIDogam9pbihjb25maWd1cmF0aW9uUm9vdChydW50aW1lKSwgZGVmaW5pdGlvbi5pZCk7XG4gIHJldHVybiB7XG4gICAgZGlyZWN0b3J5LFxuICAgIGNvbmZpZ0ZpbGU6IGpvaW4oZGlyZWN0b3J5LCBcInNlcnZpY2UuanNvblwiKSxcbiAgICBob3N0TG9nOiBqb2luKGRpcmVjdG9yeSwgXCJob3N0LmxvZ1wiKSxcbiAgICBwcm9jZXNzTG9nOiBqb2luKGRpcmVjdG9yeSwgXCJzZXJ2aWNlLmxvZ1wiKSxcbiAgICBjb250cm9sQWRkcmVzczogY29udHJvbEFkZHJlc3MoZGVmaW5pdGlvbi5pZCwgcnVudGltZSksXG4gICAgc3RhcnR1cEZpbGU6IHN0YXJ0dXBGaWxlKGRlZmluaXRpb24uaWQsIHJ1bnRpbWUpLFxuICB9O1xufVxuXG5mdW5jdGlvbiBjb25maWd1cmF0aW9uUm9vdChydW50aW1lOiBTZXJ2aWNlUnVudGltZUNvbnRleHQpOiBzdHJpbmcge1xuICBpZiAocnVudGltZS5wbGF0Zm9ybSA9PT0gXCJkYXJ3aW5cIikge1xuICAgIHJldHVybiBqb2luKHJ1bnRpbWUuaG9tZURpcmVjdG9yeSwgXCJMaWJyYXJ5XCIsIFwiQXBwbGljYXRpb24gU3VwcG9ydFwiKTtcbiAgfVxuICBpZiAocnVudGltZS5wbGF0Zm9ybSA9PT0gXCJ3aW4zMlwiKSB7XG4gICAgcmV0dXJuIHJlc29sdmVFbnZpcm9ubWVudFBhdGgoXG4gICAgICBydW50aW1lLmVudmlyb25tZW50LkFQUERBVEEsXG4gICAgICBqb2luKHJ1bnRpbWUuaG9tZURpcmVjdG9yeSwgXCJBcHBEYXRhXCIsIFwiUm9hbWluZ1wiKSxcbiAgICApO1xuICB9XG4gIHJldHVybiByZXNvbHZlRW52aXJvbm1lbnRQYXRoKFxuICAgIHJ1bnRpbWUuZW52aXJvbm1lbnQuWERHX0NPTkZJR19IT01FLFxuICAgIGpvaW4ocnVudGltZS5ob21lRGlyZWN0b3J5LCBcIi5jb25maWdcIiksXG4gICk7XG59XG5cbmZ1bmN0aW9uIGNvbnRyb2xBZGRyZXNzKGlkOiBzdHJpbmcsIHJ1bnRpbWU6IFNlcnZpY2VSdW50aW1lQ29udGV4dCk6IHN0cmluZyB7XG4gIGNvbnN0IHRva2VuID0gY3JlYXRlSGFzaChcInNoYTI1NlwiKS51cGRhdGUoaWQpLmRpZ2VzdChcImhleFwiKS5zbGljZSgwLCAxNik7XG4gIGlmIChydW50aW1lLnBsYXRmb3JtID09PSBcIndpbjMyXCIpIHtcbiAgICByZXR1cm4gYFxcXFxcXFxcLlxcXFxwaXBlXFxcXGRieC10b29scy1jbGktc2VydmljZS0ke3Rva2VufWA7XG4gIH1cbiAgcmV0dXJuIGpvaW4ocnVudGltZS50ZW1wb3JhcnlEaXJlY3RvcnksIGBkYngtdG9vbHMtY2xpLXNlcnZpY2UtJHt0b2tlbn0uc29ja2ApO1xufVxuXG5mdW5jdGlvbiBzdGFydHVwRmlsZShpZDogc3RyaW5nLCBydW50aW1lOiBTZXJ2aWNlUnVudGltZUNvbnRleHQpOiBzdHJpbmcge1xuICBpZiAocnVudGltZS5wbGF0Zm9ybSA9PT0gXCJkYXJ3aW5cIikge1xuICAgIHJldHVybiBqb2luKHJ1bnRpbWUuaG9tZURpcmVjdG9yeSwgXCJMaWJyYXJ5XCIsIFwiTGF1bmNoQWdlbnRzXCIsIGAke2lkfS5wbGlzdGApO1xuICB9XG4gIGlmIChydW50aW1lLnBsYXRmb3JtID09PSBcIndpbjMyXCIpIHtcbiAgICByZXR1cm4gam9pbihcbiAgICAgIHJlc29sdmVFbnZpcm9ubWVudFBhdGgoXG4gICAgICAgIHJ1bnRpbWUuZW52aXJvbm1lbnQuQVBQREFUQSxcbiAgICAgICAgam9pbihydW50aW1lLmhvbWVEaXJlY3RvcnksIFwiQXBwRGF0YVwiLCBcIlJvYW1pbmdcIiksXG4gICAgICApLFxuICAgICAgXCJNaWNyb3NvZnRcIixcbiAgICAgIFwiV2luZG93c1wiLFxuICAgICAgXCJTdGFydCBNZW51XCIsXG4gICAgICBcIlByb2dyYW1zXCIsXG4gICAgICBcIlN0YXJ0dXBcIixcbiAgICAgIGAke2lkfS5jbWRgLFxuICAgICk7XG4gIH1cbiAgcmV0dXJuIGpvaW4oXG4gICAgcmVzb2x2ZUVudmlyb25tZW50UGF0aChcbiAgICAgIHJ1bnRpbWUuZW52aXJvbm1lbnQuWERHX0NPTkZJR19IT01FLFxuICAgICAgam9pbihydW50aW1lLmhvbWVEaXJlY3RvcnksIFwiLmNvbmZpZ1wiKSxcbiAgICApLFxuICAgIFwiYXV0b3N0YXJ0XCIsXG4gICAgYCR7aWR9LmRlc2t0b3BgLFxuICApO1xufVxuXG5mdW5jdGlvbiByZXNvbHZlRW52aXJvbm1lbnRQYXRoKHZhbHVlOiBzdHJpbmcgfCB1bmRlZmluZWQsIGZhbGxiYWNrOiBzdHJpbmcpOiBzdHJpbmcge1xuICBpZiAoIXZhbHVlKSByZXR1cm4gZmFsbGJhY2s7XG4gIHJldHVybiBpc0Fic29sdXRlKHZhbHVlKSA/IHZhbHVlIDogcmVzb2x2ZSh2YWx1ZSk7XG59XG4iXX0=

package/lib/src/_runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function externalRuntimePackages(dependencies: Readonly<Record<string, string>>): string[];
+export declare function installServiceRuntime(bunExecutable: string, directory: string, dependencies: Readonly<Record<string, string>>): Promise<void>;

package/lib/src/_runtime.js

@@ -0,0 +1,49 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import * as exec from "@dbx-tools/core/exec";
+export function externalRuntimePackages(dependencies) {
+    return Object.keys(dependencies).filter((name) => !name.startsWith("@dbx-tools/"));
+}
+export async function installServiceRuntime(bunExecutable, directory, dependencies) {
+    await mkdir(directory, { recursive: true });
+    const manifestPath = join(directory, "package.json");
+    const current = await readOptionalRecord(manifestPath);
+    await writeFile(manifestPath, `${JSON.stringify({
+        ...current,
+        name: "@dbx-tools/service-runtime",
+        private: true,
+        dependencies: {
+            ...stringRecord(current.dependencies),
+            ...dependencies,
+        },
+    }, null, 2)}\n`, "utf8");
+    await exec.spawn(bunExecutable, ["install", "--production", "--cwd", directory], {
+        check: true,
+        cwd: directory,
+        stdin: "ignore",
+        stdout: "capture",
+        stderr: "capture",
+    });
+}
+async function readOptionalRecord(path) {
+    try {
+        const value = JSON.parse(await readFile(path, "utf8"));
+        if (!isRecord(value))
+            throw new Error(`JSON file is not an object: ${path}`);
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+function stringRecord(value) {
+    if (!isRecord(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_startup.d.ts

@@ -0,0 +1,11 @@
+import type { ServicePaths, ServiceRuntimeContext } from "./_paths.ts";
+import type { CliServiceDefinition } from "./definition.ts";
+export interface ServiceLaunch {
+    readonly executable: string;
+    readonly arguments: readonly string[];
+}
+export declare function installStartup(definition: CliServiceDefinition, paths: ServicePaths, runtime: ServiceRuntimeContext, launch: ServiceLaunch): Promise<void>;
+export declare function removeStartup(paths: ServicePaths): Promise<void>;
+export declare function renderLaunchAgent(definition: CliServiceDefinition, launch: ServiceLaunch): string;
+export declare function renderDesktopEntry(definition: CliServiceDefinition, launch: ServiceLaunch): string;
+export declare function renderWindowsStartup(launch: ServiceLaunch): string;