@dbx-tools/cli-service 0.9.36

package/lib/src/_startup.js

@@ -0,0 +1,81 @@
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export async function installStartup(definition, paths, runtime, launch) {
+    await mkdir(dirname(paths.startupFile), { recursive: true });
+    const content = runtime.platform === "darwin"
+        ? renderLaunchAgent(definition, launch)
+        : runtime.platform === "win32"
+            ? renderWindowsStartup(launch)
+            : renderDesktopEntry(definition, launch);
+    await writeFile(paths.startupFile, content, {
+        encoding: "utf8",
+        mode: runtime.platform === "win32" ? undefined : 0o644,
+    });
+}
+export async function removeStartup(paths) {
+    await rm(paths.startupFile, { force: true });
+}
+export function renderLaunchAgent(definition, launch) {
+    const argumentsXml = [launch.executable, ...launch.arguments]
+        .map((argument) => `      <string>${escapeXml(argument)}</string>`)
+        .join("\n");
+    return [
+        '<?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>${escapeXml(definition.id)}</string>`,
+        "    <key>ProgramArguments</key>",
+        "    <array>",
+        argumentsXml,
+        "    </array>",
+        "    <key>RunAtLoad</key>",
+        "    <true/>",
+        "    <key>ProcessType</key>",
+        "    <string>Interactive</string>",
+        "  </dict>",
+        "</plist>",
+        "",
+    ].join("\n");
+}
+export function renderDesktopEntry(definition, launch) {
+    return [
+        "[Desktop Entry]",
+        "Type=Application",
+        `Name=${escapeDesktopValue(definition.name)}`,
+        `Exec=${[launch.executable, ...launch.arguments].map(quoteDesktopArgument).join(" ")}`,
+        "Terminal=false",
+        "X-GNOME-Autostart-enabled=true",
+        "",
+    ].join("\n");
+}
+export function renderWindowsStartup(launch) {
+    const command = [launch.executable, ...launch.arguments].map(quoteWindowsArgument).join(" ");
+    return `@echo off\r\nstart "" /b ${command}\r\n`;
+}
+function escapeDesktopValue(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll("\n", "\\n");
+}
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
+}
+function quoteDesktopArgument(value) {
+    return `"${value
+        .replaceAll("\\", "\\\\")
+        .replaceAll('"', '\\"')
+        .replaceAll("`", "\\`")
+        .replaceAll("$", "\\$")}"`;
+}
+function quoteWindowsArgument(value) {
+    const escapedPercent = value.replaceAll("%", "%%");
+    const escapedQuotes = escapedPercent.replace(/(\\*)"/g, '$1$1\\"');
+    const escapedTrailingSlashes = escapedQuotes.replace(/(\\+)$/, "$1$1");
+    return `"${escapedTrailingSlashes}"`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_startup.js","sourceRoot":"","sources":["../../src/_startup.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdir, rm, writeFile } from \"node:fs/promises\";\nimport { dirname } from \"node:path\";\n\nimport type { ServicePaths, ServiceRuntimeContext } from \"./_paths.ts\";\nimport type { CliServiceDefinition } from \"./definition.ts\";\n\nexport interface ServiceLaunch {\n  readonly executable: string;\n  readonly arguments: readonly string[];\n}\n\nexport async function installStartup(\n  definition: CliServiceDefinition,\n  paths: ServicePaths,\n  runtime: ServiceRuntimeContext,\n  launch: ServiceLaunch,\n): Promise<void> {\n  await mkdir(dirname(paths.startupFile), { recursive: true });\n  const content =\n    runtime.platform === \"darwin\"\n      ? renderLaunchAgent(definition, launch)\n      : runtime.platform === \"win32\"\n        ? renderWindowsStartup(launch)\n        : renderDesktopEntry(definition, launch);\n  await writeFile(paths.startupFile, content, {\n    encoding: \"utf8\",\n    mode: runtime.platform === \"win32\" ? undefined : 0o644,\n  });\n}\n\nexport async function removeStartup(paths: ServicePaths): Promise<void> {\n  await rm(paths.startupFile, { force: true });\n}\n\nexport function renderLaunchAgent(definition: CliServiceDefinition, launch: ServiceLaunch): string {\n  const argumentsXml = [launch.executable, ...launch.arguments]\n    .map((argument) => `      <string>${escapeXml(argument)}</string>`)\n    .join(\"\\n\");\n  return [\n    '<?xml version=\"1.0\" encoding=\"UTF-8\"?>',\n    '<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">',\n    '<plist version=\"1.0\">',\n    \"  <dict>\",\n    \"    <key>Label</key>\",\n    `    <string>${escapeXml(definition.id)}</string>`,\n    \"    <key>ProgramArguments</key>\",\n    \"    <array>\",\n    argumentsXml,\n    \"    </array>\",\n    \"    <key>RunAtLoad</key>\",\n    \"    <true/>\",\n    \"    <key>ProcessType</key>\",\n    \"    <string>Interactive</string>\",\n    \"  </dict>\",\n    \"</plist>\",\n    \"\",\n  ].join(\"\\n\");\n}\n\nexport function renderDesktopEntry(\n  definition: CliServiceDefinition,\n  launch: ServiceLaunch,\n): string {\n  return [\n    \"[Desktop Entry]\",\n    \"Type=Application\",\n    `Name=${escapeDesktopValue(definition.name)}`,\n    `Exec=${[launch.executable, ...launch.arguments].map(quoteDesktopArgument).join(\" \")}`,\n    \"Terminal=false\",\n    \"X-GNOME-Autostart-enabled=true\",\n    \"\",\n  ].join(\"\\n\");\n}\n\nexport function renderWindowsStartup(launch: ServiceLaunch): string {\n  const command = [launch.executable, ...launch.arguments].map(quoteWindowsArgument).join(\" \");\n  return `@echo off\\r\\nstart \"\" /b ${command}\\r\\n`;\n}\n\nfunction escapeDesktopValue(value: string): string {\n  return value.replaceAll(\"\\\\\", \"\\\\\\\\\").replaceAll(\"\\n\", \"\\\\n\");\n}\n\nfunction escapeXml(value: string): string {\n  return value\n    .replaceAll(\"&\", \"&amp;\")\n    .replaceAll(\"<\", \"&lt;\")\n    .replaceAll(\">\", \"&gt;\")\n    .replaceAll('\"', \"&quot;\")\n    .replaceAll(\"'\", \"&apos;\");\n}\n\nfunction quoteDesktopArgument(value: string): string {\n  return `\"${value\n    .replaceAll(\"\\\\\", \"\\\\\\\\\")\n    .replaceAll('\"', '\\\\\"')\n    .replaceAll(\"`\", \"\\\\`\")\n    .replaceAll(\"$\", \"\\\\$\")}\"`;\n}\n\nfunction quoteWindowsArgument(value: string): string {\n  const escapedPercent = value.replaceAll(\"%\", \"%%\");\n  const escapedQuotes = escapedPercent.replace(/(\\\\*)\"/g, '$1$1\\\\\"');\n  const escapedTrailingSlashes = escapedQuotes.replace(/(\\\\+)$/, \"$1$1\");\n  return `\"${escapedTrailingSlashes}\"`;\n}\n"]}

package/lib/src/cli.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Commander command group for a system-tray service lifecycle.
+ *
+ * @module
+ */
+import { Command } from "commander";
+import type { CliServiceDefinition } from "./definition.ts";
+import { type CliServiceLifecycle } from "./service.ts";
+/** Static definition or action-time factory used by a service command group. */
+export type CliServiceDefinitionSource = CliServiceDefinition | (() => CliServiceDefinition);
+/** Injectable lifecycle and output boundary for service CLI tests and composition. */
+export interface CliServiceCliDependencies {
+    /** Construct the lifecycle manager used by command actions. */
+    create(definition: CliServiceDefinition): CliServiceLifecycle;
+    /** Write the JSON result of the status command. */
+    write(value: string): void;
+}
+/** Build install, start, stop, restart, status, and uninstall commands for a service. */
+export declare function buildServiceCommand(source: CliServiceDefinitionSource, dependencies?: CliServiceCliDependencies): Command;

package/lib/src/cli.js

@@ -0,0 +1,61 @@
+/**
+ * Commander command group for a system-tray service lifecycle.
+ *
+ * @module
+ */
+import { Command } from "commander";
+import { CliService } from "./service.js";
+const DEFAULT_DEPENDENCIES = {
+    create: (definition) => new CliService(definition),
+    write: (value) => process.stdout.write(value),
+};
+/** Build install, start, stop, restart, status, and uninstall commands for a service. */
+export function buildServiceCommand(source, dependencies = DEFAULT_DEPENDENCIES) {
+    const definition = resolveDefinition(source);
+    const service = () => dependencies.create(definition());
+    const command = new Command("service").description(typeof source === "function"
+        ? "Install and manage the desktop service"
+        : `Install and manage the ${source.name} desktop service`);
+    command
+        .command("install")
+        .description("Install the service for the current user and start it")
+        .option("--no-start", "install without starting the service")
+        .action(async (options) => {
+        await service().install({ start: options.start });
+    });
+    command
+        .command("start")
+        .description("Start the installed service")
+        .action(async () => {
+        await service().start();
+    });
+    command
+        .command("stop")
+        .description("Stop the running service")
+        .action(async () => {
+        await service().stop();
+    });
+    command
+        .command("restart")
+        .description("Restart the installed service")
+        .action(async () => {
+        await service().restart();
+    });
+    command
+        .command("status")
+        .description("Print service installation and process state as JSON")
+        .action(async () => {
+        dependencies.write(`${JSON.stringify(await service().status(), null, 2)}\n`);
+    });
+    command
+        .command("uninstall")
+        .description("Stop and remove the service for the current user")
+        .action(async () => {
+        await service().uninstall();
+    });
+    return command;
+}
+function resolveDefinition(source) {
+    return typeof source === "function" ? source : () => source;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/definition.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Serializable configuration for a system-tray CLI service.
+ *
+ * @module
+ */
+import { z } from "zod";
+/** A process launched by the system-tray service host. */
+export declare const CliServiceCommandSchema: z.ZodReadonly<z.ZodObject<{
+    executable: z.ZodOptional<z.ZodString>;
+    entrypoint: z.ZodOptional<z.ZodString>;
+    binName: z.ZodOptional<z.ZodString>;
+    arguments: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    environment: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+/** A process launched by the system-tray service host. */
+export type CliServiceCommand = z.infer<typeof CliServiceCommandSchema>;
+/** A typed custom item inserted between the default service title and Quit item. */
+export declare const CliServiceMenuItemSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"separator">;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"url">;
+    label: z.ZodString;
+    url: z.ZodString;
+}, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+    type: z.ZodLiteral<"command">;
+    label: z.ZodString;
+    command: z.ZodReadonly<z.ZodObject<{
+        executable: z.ZodOptional<z.ZodString>;
+        entrypoint: z.ZodOptional<z.ZodString>;
+        binName: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        environment: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>], "type">;
+/** A typed custom item inserted between the default service title and Quit item. */
+export type CliServiceMenuItem = z.infer<typeof CliServiceMenuItemSchema>;
+/** Complete serializable definition consumed by the lifecycle manager and tray host. */
+export declare const CliServiceDefinitionSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    packageName: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    icon: z.ZodString;
+    isTemplateIcon: z.ZodOptional<z.ZodBoolean>;
+    dataDirectory: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        executable: z.ZodOptional<z.ZodString>;
+        entrypoint: z.ZodOptional<z.ZodString>;
+        binName: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        environment: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    menu: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"separator">;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        label: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
+        type: z.ZodLiteral<"command">;
+        label: z.ZodString;
+        command: z.ZodReadonly<z.ZodObject<{
+            executable: z.ZodOptional<z.ZodString>;
+            entrypoint: z.ZodOptional<z.ZodString>;
+            binName: z.ZodOptional<z.ZodString>;
+            arguments: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            environment: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            cwd: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>], "type">>>>;
+}, z.core.$strip>>;
+/** Complete serializable definition consumed by the lifecycle manager and tray host. */
+export type CliServiceDefinition = z.infer<typeof CliServiceDefinitionSchema>;
+/** Package-derived service fields plus caller-owned icon, process, and menu options. */
+export type CliServiceDefinitionOptions = Omit<CliServiceDefinition, "packageName" | "id" | "name" | "version"> & Partial<Pick<CliServiceDefinition, "id" | "name" | "version">>;
+/** Define a service from an owning module URL or installed package name. */
+export declare function defineService(packageReference: string, options: CliServiceDefinitionOptions): CliServiceDefinition;
+/** Resolve a package's single or explicitly named executable entrypoint. */
+export declare function resolveServicePackageBin(packageReference: string, binName?: string): string;

package/lib/src/definition.js

@@ -0,0 +1,91 @@
+/**
+ * Serializable configuration for a system-tray CLI service.
+ *
+ * @module
+ */
+import { z } from "zod";
+import { resolveServicePackage, servicePackageDefaults } from "./_package.js";
+const SAFE_URL_PROTOCOLS = new Set(["http:", "https:", "mailto:"]);
+function isSafeUrl(value) {
+    try {
+        return SAFE_URL_PROTOCOLS.has(new URL(value).protocol);
+    }
+    catch {
+        return false;
+    }
+}
+/** A process launched by the system-tray service host. */
+export const CliServiceCommandSchema = z
+    .object({
+    executable: z.string().min(1).optional(),
+    entrypoint: z.string().min(1).optional(),
+    binName: z.string().min(1).optional(),
+    arguments: z.array(z.string()).readonly().optional(),
+    environment: z.record(z.string(), z.string()).readonly().optional(),
+    cwd: z.string().min(1).optional(),
+})
+    .superRefine((command, context) => {
+    if (Number(command.executable !== undefined) +
+        Number(command.entrypoint !== undefined) +
+        Number(command.binName !== undefined) >
+        1) {
+        context.addIssue({
+            code: "custom",
+            message: "command accepts at most one of executable, entrypoint, or binName",
+        });
+    }
+})
+    .readonly();
+/** A typed custom item inserted between the default service title and Quit item. */
+export const CliServiceMenuItemSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("separator") }).readonly(),
+    z
+        .object({
+        type: z.literal("url"),
+        label: z.string().min(1),
+        url: z.string().refine(isSafeUrl, "URL must use HTTP, HTTPS, or mailto"),
+    })
+        .readonly(),
+    z
+        .object({
+        type: z.literal("command"),
+        label: z.string().min(1),
+        command: CliServiceCommandSchema,
+    })
+        .readonly(),
+]);
+/** Complete serializable definition consumed by the lifecycle manager and tray host. */
+export const CliServiceDefinitionSchema = z
+    .object({
+    id: z
+        .string()
+        .min(1)
+        .max(128)
+        .regex(/^[a-z0-9][a-z0-9._-]*$/, "service id must be filesystem safe"),
+    name: z.string().min(1),
+    packageName: z.string().min(1),
+    version: z.string().min(1).optional(),
+    icon: z.string().min(1),
+    isTemplateIcon: z.boolean().optional(),
+    dataDirectory: z.string().min(1).optional(),
+    command: CliServiceCommandSchema.optional(),
+    menu: z.array(CliServiceMenuItemSchema).readonly().optional(),
+})
+    .readonly();
+/** Define a service from an owning module URL or installed package name. */
+export function defineService(packageReference, options) {
+    const pkg = resolveServicePackage(packageReference);
+    const defaults = servicePackageDefaults(pkg);
+    return CliServiceDefinitionSchema.parse({
+        ...options,
+        packageName: pkg.name,
+        id: options.id ?? defaults.id,
+        name: options.name ?? defaults.name,
+        version: options.version ?? pkg.version,
+    });
+}
+/** Resolve a package's single or explicitly named executable entrypoint. */
+export function resolveServicePackageBin(packageReference, binName) {
+    return resolveServicePackage(packageReference).bin(binName);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../src/definition.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Serializable configuration for a system-tray CLI service.\n *\n * @module\n */\n\nimport { z } from \"zod\";\n\nimport { resolveServicePackage, servicePackageDefaults } from \"./_package.ts\";\n\nconst SAFE_URL_PROTOCOLS = new Set([\"http:\", \"https:\", \"mailto:\"]);\n\nfunction isSafeUrl(value: string): boolean {\n  try {\n    return SAFE_URL_PROTOCOLS.has(new URL(value).protocol);\n  } catch {\n    return false;\n  }\n}\n\n/** A process launched by the system-tray service host. */\nexport const CliServiceCommandSchema = z\n  .object({\n    executable: z.string().min(1).optional(),\n    entrypoint: z.string().min(1).optional(),\n    binName: z.string().min(1).optional(),\n    arguments: z.array(z.string()).readonly().optional(),\n    environment: z.record(z.string(), z.string()).readonly().optional(),\n    cwd: z.string().min(1).optional(),\n  })\n  .superRefine((command, context) => {\n    if (\n      Number(command.executable !== undefined) +\n        Number(command.entrypoint !== undefined) +\n        Number(command.binName !== undefined) >\n      1\n    ) {\n      context.addIssue({\n        code: \"custom\",\n        message: \"command accepts at most one of executable, entrypoint, or binName\",\n      });\n    }\n  })\n  .readonly();\n\n/** A process launched by the system-tray service host. */\nexport type CliServiceCommand = z.infer<typeof CliServiceCommandSchema>;\n\n/** A typed custom item inserted between the default service title and Quit item. */\nexport const CliServiceMenuItemSchema = z.discriminatedUnion(\"type\", [\n  z.object({ type: z.literal(\"separator\") }).readonly(),\n  z\n    .object({\n      type: z.literal(\"url\"),\n      label: z.string().min(1),\n      url: z.string().refine(isSafeUrl, \"URL must use HTTP, HTTPS, or mailto\"),\n    })\n    .readonly(),\n  z\n    .object({\n      type: z.literal(\"command\"),\n      label: z.string().min(1),\n      command: CliServiceCommandSchema,\n    })\n    .readonly(),\n]);\n\n/** A typed custom item inserted between the default service title and Quit item. */\nexport type CliServiceMenuItem = z.infer<typeof CliServiceMenuItemSchema>;\n\n/** Complete serializable definition consumed by the lifecycle manager and tray host. */\nexport const CliServiceDefinitionSchema = z\n  .object({\n    id: z\n      .string()\n      .min(1)\n      .max(128)\n      .regex(/^[a-z0-9][a-z0-9._-]*$/, \"service id must be filesystem safe\"),\n    name: z.string().min(1),\n    packageName: z.string().min(1),\n    version: z.string().min(1).optional(),\n    icon: z.string().min(1),\n    isTemplateIcon: z.boolean().optional(),\n    dataDirectory: z.string().min(1).optional(),\n    command: CliServiceCommandSchema.optional(),\n    menu: z.array(CliServiceMenuItemSchema).readonly().optional(),\n  })\n  .readonly();\n\n/** Complete serializable definition consumed by the lifecycle manager and tray host. */\nexport type CliServiceDefinition = z.infer<typeof CliServiceDefinitionSchema>;\n\n/** Package-derived service fields plus caller-owned icon, process, and menu options. */\nexport type CliServiceDefinitionOptions = Omit<\n  CliServiceDefinition,\n  \"packageName\" | \"id\" | \"name\" | \"version\"\n> &\n  Partial<Pick<CliServiceDefinition, \"id\" | \"name\" | \"version\">>;\n\n/** Define a service from an owning module URL or installed package name. */\nexport function defineService(\n  packageReference: string,\n  options: CliServiceDefinitionOptions,\n): CliServiceDefinition {\n  const pkg = resolveServicePackage(packageReference);\n  const defaults = servicePackageDefaults(pkg);\n  return CliServiceDefinitionSchema.parse({\n    ...options,\n    packageName: pkg.name,\n    id: options.id ?? defaults.id,\n    name: options.name ?? defaults.name,\n    version: options.version ?? pkg.version,\n  });\n}\n\n/** Resolve a package's single or explicitly named executable entrypoint. */\nexport function resolveServicePackageBin(packageReference: string, binName?: string): string {\n  return resolveServicePackage(packageReference).bin(binName);\n}\n"]}

package/lib/src/service.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Install, start, stop, and inspect a system-tray user service.
+ *
+ * @module
+ */
+import { type CliServiceDefinition } from "./definition.ts";
+/** Compile one TypeScript or JavaScript entrypoint into a standalone executable. */
+export type CliServiceCompiler = (entrypoint: string, output: string, workingDirectory: string, external?: readonly string[]) => Promise<void>;
+/** Install exact external runtime dependencies into the dbx-tools home. */
+export type CliServiceRuntimeInstaller = (bunExecutable: string, directory: string, dependencies: Readonly<Record<string, string>>) => Promise<void>;
+/** Host runtime overrides for tests, embedded distributions, and nonstandard homes. */
+export interface CliServiceRuntimeOptions {
+    /** Operating system used for configuration and startup registration. */
+    readonly platform?: NodeJS.Platform;
+    /** Environment used to locate platform configuration directories. */
+    readonly environment?: Readonly<NodeJS.ProcessEnv>;
+    /** Home directory used when platform environment variables are absent. */
+    readonly homeDirectory?: string;
+    /** Temporary directory used for the local control socket. */
+    readonly temporaryDirectory?: string;
+    /** Shared dbx-tools home containing installed service binaries. */
+    readonly globalHomeDirectory?: string;
+    /** Package-provided Bun executable override. */
+    readonly bunExecutable?: string;
+    /** Standalone compiler override. */
+    readonly compile?: CliServiceCompiler;
+    /** External runtime dependency installer override. */
+    readonly installRuntime?: CliServiceRuntimeInstaller;
+    /** System-tray host source entrypoint override. */
+    readonly hostEntrypoint?: string;
+    /** systray2 native executable override. */
+    readonly trayExecutable?: string;
+}
+/** Options controlling service installation. */
+export interface CliServiceInstallOptions {
+    /** Start the service immediately after writing its configuration and login entry. */
+    readonly start?: boolean;
+}
+/** Current installation and process state for a system-tray service. */
+export interface CliServiceStatus {
+    /** Whether the serialized service definition exists. */
+    readonly installed: boolean;
+    /** Whether the tray host answered its local control socket. */
+    readonly running: boolean;
+    /** Tray host process ID when running. */
+    readonly pid?: number;
+    /** Managed child process ID when the definition includes a command. */
+    readonly servicePid?: number;
+}
+/** Lifecycle contract consumed by CLI command builders. */
+export interface CliServiceLifecycle {
+    /** Install the login entry and optionally start the service. */
+    install(options?: CliServiceInstallOptions): Promise<void>;
+    /** Start the installed service when it is not already running. */
+    start(): Promise<void>;
+    /** Stop the running tray host and its managed child process. */
+    stop(): Promise<void>;
+    /** Stop and start the installed service. */
+    restart(): Promise<void>;
+    /** Stop the service and remove its login entry and package-owned state. */
+    uninstall(): Promise<void>;
+    /** Read the current installation and process state. */
+    status(): Promise<CliServiceStatus>;
+}
+/** Cross-platform lifecycle manager for one system-tray user service. */
+export declare class CliService implements CliServiceLifecycle {
+    readonly definition: CliServiceDefinition;
+    private readonly runtime;
+    private readonly globalHomeDirectory;
+    private readonly bunExecutable;
+    private readonly compiler;
+    private readonly runtimeInstaller;
+    private readonly hostEntrypoint;
+    private readonly trayExecutable;
+    /**
+     * Create a lifecycle manager from a serializable definition.
+     *
+     * @param definition Product-owned service metadata, process, and menu.
+     * @param options Host runtime overrides.
+     */
+    constructor(definition: CliServiceDefinition, options?: CliServiceRuntimeOptions);
+    /** Install the login entry and optionally start the service. */
+    install(options?: CliServiceInstallOptions): Promise<void>;
+    /** Start the installed service when it is not already running. */
+    start(): Promise<void>;
+    /** Stop the running tray host and its managed child process. */
+    stop(): Promise<void>;
+    /** Stop and start the installed service. */
+    restart(): Promise<void>;
+    /** Stop the service and remove its login entry and package-owned state. */
+    uninstall(): Promise<void>;
+    /** Read the current installation and process state. */
+    status(): Promise<CliServiceStatus>;
+    private launch;
+    private installDefinition;
+    private installCommand;
+    private ensureCompiledBinary;
+    private ensureTrayBinary;
+    private binaryContext;
+    private binaryName;
+}