@dbx-tools/cli-service 0.9.38 → 0.9.43

package/README.md

@@ -1,27 +1,12 @@
 # @dbx-tools/cli-service
 
-Product-agnostic system-tray service lifecycle for Node and Bun CLIs. A
-consuming Commander program gets `service install`, `start`, `stop`, `restart`,
-`status`, and `uninstall` commands from one typed definition.
+Add desktop-service installation, lifecycle commands, and a tray menu to a
+Commander CLI. Users can keep your command running after their terminal closes
+and manage it through the same `service` commands on macOS, Linux, and Windows.
 
-This is the shared owner for current-user CLI services. Product CLIs should
-provide a service definition and reuse this lifecycle instead of implementing
-their own installers, startup registration, tray host, runtime layout, or
-control channel.
-
-The resident `systray2` host can manage a foreground command and display a
-system tray icon. Its default menu contains:
-
-- `<program name> - <version>`
-- `Quit`
-
-Custom menu items can open an external URL, run a command, or add a separator.
-
-## Usage
+## Add Service Commands
 
 ```ts
-import { fileURLToPath } from "node:url";
-
 import { buildServiceCommand } from "@dbx-tools/cli-service/cli";
 import { defineService } from "@dbx-tools/cli-service/definition";
 import { Command } from "commander";
@@ -30,44 +15,149 @@ const program = new Command("example");
 program.addCommand(
   buildServiceCommand(
     defineService(import.meta.url, {
-      icon: fileURLToPath(new URL("../assets/icon.png", import.meta.url)),
-      command: {
-        arguments: ["serve"],
-      },
-      menu: [
-        {
-          type: "url",
-          label: "Models",
-          url: "http://127.0.0.1:4400/v1/models",
-        },
-      ],
+      command: { arguments: ["serve"] },
+      menu: [{ type: "url", label: "Open App", url: "http://127.0.0.1:4400" }],
     }),
   ),
 );
+await program.parseAsync(process.argv);
+```
+
+`defineService` uses the owning package's name, version, and default executable.
+Use `command.binName` when the package has multiple executable entries. Set
+`command.executable` to run an existing external program instead of compiling a
+package entrypoint. Managed commands default `NODE_ENV` to `production`; an
+explicit `command.environment.NODE_ENV` overrides it.
+
+`command.options` accepts either a concrete option object or a Zod object
+schema. Objects serialize their current values. Schemas parse `{}` and serialize
+their defaults. Boolean values become positive or negated flags, arrays become
+repeated flags, and `undefined` values are omitted:
+
+```ts
+defineService(import.meta.url, {
+  command: {
+    arguments: ["serve"],
+    options: {
+      host: "127.0.0.1",
+      port: 4400,
+      telemetry: false,
+    },
+  },
+});
+```
+
+## Install And Manage The Service
+
+For the example program above:
+
+```sh
+example service install
+example service status
+example service stop
+example service start
+example service restart
+example service uninstall
+```
+
+Installation starts the service by default. Pass `--no-start` to install without
+launching it. `status` reports installation and process state as JSON.
+
+The service belongs to the current user. Login startup uses a LaunchAgent on
+macOS, an XDG autostart entry on Linux, and a Startup command on Windows. Package
+entrypoints are compiled with Bun into `~/.dbx-tools/bin`.
+
+`restart` stops and starts the installed executable; it does not rebuild it.
+Re-run `install` after upgrading a consuming package to replace compiled
+executables and update the saved configuration.
+
+## Customize The Tray Menu
+
+The default tray menu shows the program name and version and offers `Quit`.
+Add URL, command, or separator items through the service definition. Custom
+command items can select a package binary or an external executable just like
+the main service command.
+
+Use this package when adding service support to another CLI so users get the
+same installation, lifecycle commands, and tray behavior. The generated
+reference uses `<cli>` as a placeholder for the consuming program's name.
+
+<!-- cli-reference:start -->
+
+## Command Reference
+
+### `<cli> service`
+
+Install and manage the desktop service
+
+```sh
+<cli> service [command]
+```
+
+#### Commands
+
+| Command             | Description                                           |
+| ------------------- | ----------------------------------------------------- |
+| `install [options]` | Install the service for the current user and start it |
+| `start`             | Start the installed service                           |
+| `stop`              | Stop the running service                              |
+| `restart`           | Restart the installed service                         |
+| `status`            | Print service installation and process state as JSON  |
+| `uninstall`         | Stop and remove the service for the current user      |
+
+### `<cli> service install`
+
+Install the service for the current user and start it
+
+```sh
+<cli> service install [options]
+```
+
+#### Options
+
+| Option       | Description                                                       |
+| ------------ | ----------------------------------------------------------------- |
+| `--start`    | Start the service after installation. (default: true, env: START) |
+| `--no-start` | Disable start the service after installation.                     |
+
+### `<cli> service start`
+
+Start the installed service
+
+```sh
+<cli> service start
+```
+
+### `<cli> service stop`
+
+Stop the running service
+
+```sh
+<cli> service stop
+```
+
+### `<cli> service restart`
+
+Restart the installed service
+
+```sh
+<cli> service restart
+```
+
+### `<cli> service status`
+
+Print service installation and process state as JSON
+
+```sh
+<cli> service status
+```
+
+### `<cli> service uninstall`
+
+Stop and remove the service for the current user
+
+```sh
+<cli> service uninstall
 ```
 
-`defineService()` accepts an owning module's `import.meta.url` or a package name.
-It derives package name, version, service ID, display name, and a single default
-bin from the package manifest. Package names resolve from installed packages
-first and then from current monorepo workspace manifests. Override `version`,
-`id`, `name`, or `command.binName` only when those defaults are not appropriate.
-
-`service install` uses the package's Bun dependency to compile the tray host and
-each package bin or explicit command entrypoint. Standalone executables are
-installed under `~/.dbx-tools/bin` through `@dbx-tools/core/bin`. Direct
-third-party package dependencies are derived from the owner manifest and
-installed under `~/.dbx-tools/node_modules`; callers do not maintain an external
-package list. systray2's native helper is installed under
-`~/.dbx-tools/bin/traybin`. Startup therefore does not require a globally
-installed Node or Bun runtime. Set `command.executable` only for an already-built
-external program that should not be compiled.
-
-macOS installs a per-user LaunchAgent, Linux installs an XDG autostart desktop
-entry, and Windows installs a current-user Startup command. Start, stop, and
-status use a local socket or named pipe rather than process-name matching.
-
-## Publication
-
-This package is public because generated package output is compiled with `tsc`,
-not bundled into consuming CLIs. A private workspace package would leave a
-published CLI with an unavailable runtime dependency.
+<!-- cli-reference:end -->

package/index.ts

@@ -3,13 +3,14 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/cli-service";
-export const PACKAGE_VERSION = "0.9.38";
+export const PACKAGE_VERSION = "0.9.43";
 export * as cli from "./src/cli.ts";
 export * as definition from "./src/definition.ts";
 export * as icon from "./src/icon.ts";
 export * as service from "./src/service.ts";
+export { CliServiceInstallOptionsSchema } from "./src/cli.ts";
 export type { CliServiceDefinitionSource, CliServiceCliDependencies } from "./src/cli.ts";
 export { CliServiceCommandSchema, CliServiceMenuItemSchema, CliServiceDefinitionSchema } from "./src/definition.ts";
-export type { CliServiceCommand, CliServiceMenuItem, CliServiceDefinition, CliServiceDefinitionOptions } from "./src/definition.ts";
+export type { CliServiceCommand, CliServiceCommandInput, CliServiceMenuItem, CliServiceDefinition, CliServiceDefinitionOptions } from "./src/definition.ts";
 export { CliService } from "./src/service.ts";
-export type { CliServiceCompiler, CliServiceRuntimeInstaller, CliServiceRuntimeOptions, CliServiceInstallOptions, CliServiceStatus, CliServiceLifecycle } from "./src/service.ts";
+export type { CliServiceCompiler, CliServiceRuntimeInstaller, CliServiceRuntimeOptions, CliServiceStatus, CliServiceLifecycle } from "./src/service.ts";

package/lib/index.d.ts

@@ -1,11 +1,12 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/cli-service";
-export declare const PACKAGE_VERSION = "0.9.38";
+export declare const PACKAGE_VERSION = "0.9.43";
 export * as cli from "./src/cli.ts";
 export * as definition from "./src/definition.ts";
 export * as icon from "./src/icon.ts";
 export * as service from "./src/service.ts";
+export { CliServiceInstallOptionsSchema } from "./src/cli.ts";
 export type { CliServiceDefinitionSource, CliServiceCliDependencies } from "./src/cli.ts";
 export { CliServiceCommandSchema, CliServiceMenuItemSchema, CliServiceDefinitionSchema } from "./src/definition.ts";
-export type { CliServiceCommand, CliServiceMenuItem, CliServiceDefinition, CliServiceDefinitionOptions } from "./src/definition.ts";
+export type { CliServiceCommand, CliServiceCommandInput, CliServiceMenuItem, CliServiceDefinition, CliServiceDefinitionOptions } from "./src/definition.ts";
 export { CliService } from "./src/service.ts";
-export type { CliServiceCompiler, CliServiceRuntimeInstaller, CliServiceRuntimeOptions, CliServiceInstallOptions, CliServiceStatus, CliServiceLifecycle } from "./src/service.ts";
+export type { CliServiceCompiler, CliServiceRuntimeInstaller, CliServiceRuntimeOptions, CliServiceStatus, CliServiceLifecycle } from "./src/service.ts";

package/lib/index.js

@@ -2,11 +2,12 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/cli-service";
-export const PACKAGE_VERSION = "0.9.38";
+export const PACKAGE_VERSION = "0.9.43";
 export * as cli from "./src/cli.js";
 export * as definition from "./src/definition.js";
 export * as icon from "./src/icon.js";
 export * as service from "./src/service.js";
+export { CliServiceInstallOptionsSchema } from "./src/cli.js";
 export { CliServiceCommandSchema, CliServiceMenuItemSchema, CliServiceDefinitionSchema } from "./src/definition.js";
 export { CliService } from "./src/service.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/cli.d.ts

@@ -7,6 +7,7 @@
  * @module
  */
 import { Command } from "commander";
+import { z } from "zod";
 import type { CliServiceDefinition } from "./definition.ts";
 import { type CliServiceLifecycle } from "./service.ts";
 /** Static definition or action-time factory used by a service command group. */
@@ -18,5 +19,9 @@ export interface CliServiceCliDependencies {
     /** Write the JSON result of the status command. */
     write(value: string): void;
 }
+export declare const CliServiceInstallOptionsSchema: z.ZodObject<{
+    start: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type CliServiceInstallOptions = z.output<typeof CliServiceInstallOptionsSchema>;
 /** 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

@@ -6,12 +6,20 @@
  *
  * @module
  */
+import { addArgs, parseArgs } from "@dbx-tools/cli-args/args";
 import { Command } from "commander";
+import { z } from "zod";
 import { CliService } from "./service.js";
 const DEFAULT_DEPENDENCIES = {
     create: (definition) => new CliService(definition),
     write: (value) => process.stdout.write(value),
 };
+export const CliServiceInstallOptionsSchema = z
+    .object({
+    start: z.boolean().default(true).describe("Start the service after installation."),
+})
+    .strict()
+    .describe("Options for installing a current-user CLI service.");
 /** Build install, start, stop, restart, status, and uninstall commands for a service. */
 export function buildServiceCommand(source, dependencies = DEFAULT_DEPENDENCIES) {
     const definition = resolveDefinition(source);
@@ -19,11 +27,9 @@ export function buildServiceCommand(source, dependencies = DEFAULT_DEPENDENCIES)
     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) => {
+    const install = addArgs(command.command("install").description("Install the service for the current user and start it"), CliServiceInstallOptionsSchema, { scope: [] });
+    install.action(async () => {
+        const options = parseArgs(install, CliServiceInstallOptionsSchema);
         await service().install({ start: options.start });
     });
     command
@@ -61,4 +67,4 @@ export function buildServiceCommand(source, dependencies = DEFAULT_DEPENDENCIES)
 function resolveDefinition(source) {
     return typeof source === "function" ? source : () => source;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Commander command group for the shared system-tray service lifecycle.\n *\n * Consuming CLIs should mount {@link buildServiceCommand} instead of defining\n * package-local install/start/stop/status commands with divergent behavior.\n *\n * @module\n */\n\nimport { addArgs, parseArgs } from \"@dbx-tools/cli-args/args\";\nimport { Command } from \"commander\";\nimport { z } from \"zod\";\n\nimport type { CliServiceDefinition } from \"./definition.ts\";\nimport { CliService, type CliServiceLifecycle } from \"./service.ts\";\n\n/** Static definition or action-time factory used by a service command group. */\nexport type CliServiceDefinitionSource = CliServiceDefinition | (() => CliServiceDefinition);\n\n/** Injectable lifecycle and output boundary for service CLI tests and composition. */\nexport interface CliServiceCliDependencies {\n  /** Construct the lifecycle manager used by command actions. */\n  create(definition: CliServiceDefinition): CliServiceLifecycle;\n  /** Write the JSON result of the status command. */\n  write(value: string): void;\n}\n\nconst DEFAULT_DEPENDENCIES: CliServiceCliDependencies = {\n  create: (definition) => new CliService(definition),\n  write: (value) => process.stdout.write(value),\n};\n\nexport const CliServiceInstallOptionsSchema = z\n  .object({\n    start: z.boolean().default(true).describe(\"Start the service after installation.\"),\n  })\n  .strict()\n  .describe(\"Options for installing a current-user CLI service.\");\n\nexport type CliServiceInstallOptions = z.output<typeof CliServiceInstallOptionsSchema>;\n\n/** Build install, start, stop, restart, status, and uninstall commands for a service. */\nexport function buildServiceCommand(\n  source: CliServiceDefinitionSource,\n  dependencies: CliServiceCliDependencies = DEFAULT_DEPENDENCIES,\n): Command {\n  const definition = resolveDefinition(source);\n  const service = () => dependencies.create(definition());\n  const command = new Command(\"service\").description(\n    typeof source === \"function\"\n      ? \"Install and manage the desktop service\"\n      : `Install and manage the ${source.name} desktop service`,\n  );\n\n  const install = addArgs(\n    command.command(\"install\").description(\"Install the service for the current user and start it\"),\n    CliServiceInstallOptionsSchema,\n    { scope: [] },\n  );\n  install.action(async () => {\n    const options = parseArgs(install, CliServiceInstallOptionsSchema);\n    await service().install({ start: options.start });\n  });\n\n  command\n    .command(\"start\")\n    .description(\"Start the installed service\")\n    .action(async () => {\n      await service().start();\n    });\n\n  command\n    .command(\"stop\")\n    .description(\"Stop the running service\")\n    .action(async () => {\n      await service().stop();\n    });\n\n  command\n    .command(\"restart\")\n    .description(\"Restart the installed service\")\n    .action(async () => {\n      await service().restart();\n    });\n\n  command\n    .command(\"status\")\n    .description(\"Print service installation and process state as JSON\")\n    .action(async () => {\n      dependencies.write(`${JSON.stringify(await service().status(), null, 2)}\\n`);\n    });\n\n  command\n    .command(\"uninstall\")\n    .description(\"Stop and remove the service for the current user\")\n    .action(async () => {\n      await service().uninstall();\n    });\n\n  return command;\n}\n\nfunction resolveDefinition(source: CliServiceDefinitionSource): () => CliServiceDefinition {\n  return typeof source === \"function\" ? source : () => source;\n}\n"]}

package/lib/src/definition.d.ts

@@ -7,6 +7,7 @@
  *
  * @module
  */
+import { type ArgumentSource } from "@dbx-tools/cli-args/args";
 import { z } from "zod";
 /** A process launched by the system-tray service host. */
 export declare const CliServiceCommandSchema: z.ZodReadonly<z.ZodObject<{
@@ -19,6 +20,13 @@ export declare const CliServiceCommandSchema: z.ZodReadonly<z.ZodObject<{
 }, z.core.$strip>>;
 /** A process launched by the system-tray service host. */
 export type CliServiceCommand = z.infer<typeof CliServiceCommandSchema>;
+/** Command input accepted by {@link defineService} before option serialization. */
+export type CliServiceCommandInput = Omit<CliServiceCommand, "arguments"> & {
+    /** Positional or pre-serialized arguments placed before generated options. */
+    readonly arguments?: readonly string[];
+    /** Zod defaults or concrete option values converted into CLI flags. */
+    readonly options?: ArgumentSource;
+};
 /** 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">;
@@ -79,7 +87,10 @@ export declare const CliServiceDefinitionSchema: z.ZodReadonly<z.ZodObject<{
 /** 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" | "icon" | "isTemplateIcon"> & Partial<Pick<CliServiceDefinition, "id" | "name" | "version" | "icon" | "isTemplateIcon">>;
+export type CliServiceDefinitionOptions = Omit<CliServiceDefinition, "packageName" | "id" | "name" | "version" | "icon" | "isTemplateIcon" | "command"> & Partial<Pick<CliServiceDefinition, "id" | "name" | "version" | "icon" | "isTemplateIcon">> & {
+    /** Service process command with optional schema or object-backed options. */
+    readonly command?: CliServiceCommandInput;
+};
 /** 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. */

package/lib/src/definition.js

@@ -7,6 +7,7 @@
  *
  * @module
  */
+import { serializeArgs } from "@dbx-tools/cli-args/args";
 import { z } from "zod";
 import { resolveServicePackage, servicePackageDefaults } from "./_package.js";
 import { serviceTrayIcon } from "./icon.js";
@@ -81,18 +82,34 @@ export const CliServiceDefinitionSchema = z
 export function defineService(packageReference, options) {
     const pkg = resolveServicePackage(packageReference);
     const defaults = servicePackageDefaults(pkg);
+    const { command, ...definition } = options;
     return CliServiceDefinitionSchema.parse({
-        ...options,
+        ...definition,
+        command: resolveServiceCommand(command),
         packageName: pkg.name,
-        id: options.id ?? defaults.id,
-        name: options.name ?? defaults.name,
-        version: options.version ?? pkg.version,
-        icon: options.icon ?? serviceTrayIcon(),
-        isTemplateIcon: options.isTemplateIcon ?? process.platform === "darwin",
+        id: definition.id ?? defaults.id,
+        name: definition.name ?? defaults.name,
+        version: definition.version ?? pkg.version,
+        icon: definition.icon ?? serviceTrayIcon(),
+        isTemplateIcon: definition.isTemplateIcon ?? process.platform === "darwin",
+    });
+}
+function resolveServiceCommand(command) {
+    if (!command)
+        return undefined;
+    const { options, ...definition } = command;
+    const arguments_ = [
+        ...(definition.arguments ?? []),
+        ...(options === undefined ? [] : serializeArgs(options)),
+    ];
+    return CliServiceCommandSchema.parse({
+        ...definition,
+        environment: { NODE_ENV: "production", ...definition.environment },
+        ...(arguments_.length > 0 ? { arguments: arguments_ } : {}),
     });
 }
 /** 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":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAEnE,SAAS,SAAS,CAAC,KAAa;IAC9B,IAAI,CAAC;QACH,OAAO,kBAAkB,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,CAAC;IACzD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,0DAA0D;AAC1D,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC;KACrC,MAAM,CAAC;IACN,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACxC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACxC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACrC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACpD,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACnE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CAClC,CAAC;KACD,WAAW,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE;IAChC,IACE,MAAM,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,CAAC;QACtC,MAAM,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,CAAC;QACxC,MAAM,CAAC,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC;QACvC,CAAC,EACD,CAAC;QACD,OAAO,CAAC,QAAQ,CAAC;YACf,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,mEAAmE;SAC7E,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC;KACD,QAAQ,EAAE,CAAC;AAKd,oFAAoF;AACpF,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IACnE,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE;IACrD,CAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;QACtB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QACxB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,qCAAqC,CAAC;KACzE,CAAC;SACD,QAAQ,EAAE;IACb,CAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QAC1B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QACxB,OAAO,EAAE,uBAAuB;KACjC,CAAC;SACD,QAAQ,EAAE;CACd,CAAC,CAAC;AAKH,wFAAwF;AACxF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC;KACxC,MAAM,CAAC;IACN,EAAE,EAAE,CAAC;SACF,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,GAAG,CAAC;SACR,KAAK,CAAC,wBAAwB,EAAE,oCAAoC,CAAC;IACxE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACrC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACtC,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC3C,OAAO,EAAE,uBAAuB,CAAC,QAAQ,EAAE;IAC3C,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CAC9D,CAAC;KACD,QAAQ,EAAE,CAAC;AAYd,4EAA4E;AAC5E,MAAM,UAAU,aAAa,CAC3B,gBAAwB,EACxB,OAAoC;IAEpC,MAAM,GAAG,GAAG,qBAAqB,CAAC,gBAAgB,CAAC,CAAC;IACpD,MAAM,QAAQ,GAAG,sBAAsB,CAAC,GAAG,CAAC,CAAC;IAC7C,OAAO,0BAA0B,CAAC,KAAK,CAAC;QACtC,GAAG,OAAO;QACV,WAAW,EAAE,GAAG,CAAC,IAAI;QACrB,EAAE,EAAE,OAAO,CAAC,EAAE,IAAI,QAAQ,CAAC,EAAE;QAC7B,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI;QACnC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO;QACvC,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,eAAe,EAAE;QACvC,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,OAAO,CAAC,QAAQ,KAAK,QAAQ;KACxE,CAAC,CAAC;AACL,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,wBAAwB,CAAC,gBAAwB,EAAE,OAAgB;IACjF,OAAO,qBAAqB,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AAC9D,CAAC","sourcesContent":["/**\n * Serializable configuration for a system-tray CLI service.\n *\n * This module owns the cross-package service definition contract, package\n * identity defaults, process command, icon, and menu schema. Reuse\n * {@link defineService} instead of maintaining another service manifest shape.\n *\n * @module\n */\n\nimport { z } from \"zod\";\n\nimport { resolveServicePackage, servicePackageDefaults } from \"./_package.ts\";\nimport { serviceTrayIcon } from \"./icon.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\" | \"icon\" | \"isTemplateIcon\"\n> &\n  Partial<Pick<CliServiceDefinition, \"id\" | \"name\" | \"version\" | \"icon\" | \"isTemplateIcon\">>;\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    icon: options.icon ?? serviceTrayIcon(),\n    isTemplateIcon: options.isTemplateIcon ?? process.platform === \"darwin\",\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"]}
+//# 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 * This module owns the cross-package service definition contract, package\n * identity defaults, process command, icon, and menu schema. Reuse\n * {@link defineService} instead of maintaining another service manifest shape.\n *\n * @module\n */\n\nimport { serializeArgs, type ArgumentSource } from \"@dbx-tools/cli-args/args\";\nimport { z } from \"zod\";\n\nimport { resolveServicePackage, servicePackageDefaults } from \"./_package.ts\";\nimport { serviceTrayIcon } from \"./icon.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/** Command input accepted by {@link defineService} before option serialization. */\nexport type CliServiceCommandInput = Omit<CliServiceCommand, \"arguments\"> & {\n  /** Positional or pre-serialized arguments placed before generated options. */\n  readonly arguments?: readonly string[];\n  /** Zod defaults or concrete option values converted into CLI flags. */\n  readonly options?: ArgumentSource;\n};\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\" | \"icon\" | \"isTemplateIcon\" | \"command\"\n> &\n  Partial<Pick<CliServiceDefinition, \"id\" | \"name\" | \"version\" | \"icon\" | \"isTemplateIcon\">> & {\n    /** Service process command with optional schema or object-backed options. */\n    readonly command?: CliServiceCommandInput;\n  };\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  const { command, ...definition } = options;\n  return CliServiceDefinitionSchema.parse({\n    ...definition,\n    command: resolveServiceCommand(command),\n    packageName: pkg.name,\n    id: definition.id ?? defaults.id,\n    name: definition.name ?? defaults.name,\n    version: definition.version ?? pkg.version,\n    icon: definition.icon ?? serviceTrayIcon(),\n    isTemplateIcon: definition.isTemplateIcon ?? process.platform === \"darwin\",\n  });\n}\n\nfunction resolveServiceCommand(\n  command: CliServiceCommandInput | undefined,\n): CliServiceCommand | undefined {\n  if (!command) return undefined;\n  const { options, ...definition } = command;\n  const arguments_ = [\n    ...(definition.arguments ?? []),\n    ...(options === undefined ? [] : serializeArgs(options)),\n  ];\n  return CliServiceCommandSchema.parse({\n    ...definition,\n    environment: { NODE_ENV: \"production\", ...definition.environment },\n    ...(arguments_.length > 0 ? { arguments: arguments_ } : {}),\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/package.json

@@ -23,7 +23,8 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/core": "^0.9.38",
+    "@dbx-tools/cli-args": "^0.9.43",
+    "@dbx-tools/core": "^0.9.43",
     "bun": "1.3.14",
     "commander": "^15.0.0",
     "systray2": "^2.1.4",
@@ -59,7 +60,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.38",
+  "version": "0.9.43",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [

package/src/cli.ts

@@ -7,7 +7,9 @@
  * @module
  */
 
+import { addArgs, parseArgs } from "@dbx-tools/cli-args/args";
 import { Command } from "commander";
+import { z } from "zod";
 
 import type { CliServiceDefinition } from "./definition.ts";
 import { CliService, type CliServiceLifecycle } from "./service.ts";
@@ -28,6 +30,15 @@ const DEFAULT_DEPENDENCIES: CliServiceCliDependencies = {
   write: (value) => process.stdout.write(value),
 };
 
+export const CliServiceInstallOptionsSchema = z
+  .object({
+    start: z.boolean().default(true).describe("Start the service after installation."),
+  })
+  .strict()
+  .describe("Options for installing a current-user CLI service.");
+
+export type CliServiceInstallOptions = z.output<typeof CliServiceInstallOptionsSchema>;
+
 /** Build install, start, stop, restart, status, and uninstall commands for a service. */
 export function buildServiceCommand(
   source: CliServiceDefinitionSource,
@@ -41,13 +52,15 @@ export function buildServiceCommand(
       : `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: { start: boolean }) => {
-      await service().install({ start: options.start });
-    });
+  const install = addArgs(
+    command.command("install").description("Install the service for the current user and start it"),
+    CliServiceInstallOptionsSchema,
+    { scope: [] },
+  );
+  install.action(async () => {
+    const options = parseArgs(install, CliServiceInstallOptionsSchema);
+    await service().install({ start: options.start });
+  });
 
   command
     .command("start")

package/src/definition.ts

@@ -8,6 +8,7 @@
  * @module
  */
 
+import { serializeArgs, type ArgumentSource } from "@dbx-tools/cli-args/args";
 import { z } from "zod";
 
 import { resolveServicePackage, servicePackageDefaults } from "./_package.ts";
@@ -51,6 +52,14 @@ export const CliServiceCommandSchema = z
 /** A process launched by the system-tray service host. */
 export type CliServiceCommand = z.infer<typeof CliServiceCommandSchema>;
 
+/** Command input accepted by {@link defineService} before option serialization. */
+export type CliServiceCommandInput = Omit<CliServiceCommand, "arguments"> & {
+  /** Positional or pre-serialized arguments placed before generated options. */
+  readonly arguments?: readonly string[];
+  /** Zod defaults or concrete option values converted into CLI flags. */
+  readonly options?: ArgumentSource;
+};
+
 /** 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(),
@@ -98,9 +107,12 @@ 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" | "icon" | "isTemplateIcon"
+  "packageName" | "id" | "name" | "version" | "icon" | "isTemplateIcon" | "command"
 > &
-  Partial<Pick<CliServiceDefinition, "id" | "name" | "version" | "icon" | "isTemplateIcon">>;
+  Partial<Pick<CliServiceDefinition, "id" | "name" | "version" | "icon" | "isTemplateIcon">> & {
+    /** Service process command with optional schema or object-backed options. */
+    readonly command?: CliServiceCommandInput;
+  };
 
 /** Define a service from an owning module URL or installed package name. */
 export function defineService(
@@ -109,14 +121,32 @@ export function defineService(
 ): CliServiceDefinition {
   const pkg = resolveServicePackage(packageReference);
   const defaults = servicePackageDefaults(pkg);
+  const { command, ...definition } = options;
   return CliServiceDefinitionSchema.parse({
-    ...options,
+    ...definition,
+    command: resolveServiceCommand(command),
     packageName: pkg.name,
-    id: options.id ?? defaults.id,
-    name: options.name ?? defaults.name,
-    version: options.version ?? pkg.version,
-    icon: options.icon ?? serviceTrayIcon(),
-    isTemplateIcon: options.isTemplateIcon ?? process.platform === "darwin",
+    id: definition.id ?? defaults.id,
+    name: definition.name ?? defaults.name,
+    version: definition.version ?? pkg.version,
+    icon: definition.icon ?? serviceTrayIcon(),
+    isTemplateIcon: definition.isTemplateIcon ?? process.platform === "darwin",
+  });
+}
+
+function resolveServiceCommand(
+  command: CliServiceCommandInput | undefined,
+): CliServiceCommand | undefined {
+  if (!command) return undefined;
+  const { options, ...definition } = command;
+  const arguments_ = [
+    ...(definition.arguments ?? []),
+    ...(options === undefined ? [] : serializeArgs(options)),
+  ];
+  return CliServiceCommandSchema.parse({
+    ...definition,
+    environment: { NODE_ENV: "production", ...definition.environment },
+    ...(arguments_.length > 0 ? { arguments: arguments_ } : {}),
   });
 }