@dbx-tools/cli-service 0.9.40 → 0.9.46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1,8 +1,9 @@
1
1
  # @dbx-tools/cli-service
2
2
 
3
- Add desktop-service installation, lifecycle commands, and a tray menu to a
4
- Commander CLI. Users can keep your command running after their terminal closes
5
- and manage it through the same `service` commands on macOS, Linux, and Windows.
3
+ Add desktop-service installation, lifecycle commands, optional uv-managed
4
+ Python dependencies, and a tray menu to a Commander CLI. Users can keep your
5
+ command running after their terminal closes and manage it through the same
6
+ `service` commands on macOS, Linux, and Windows.
6
7
 
7
8
  ## Add Service Commands
8
9
 
@@ -26,7 +27,42 @@ await program.parseAsync(process.argv);
26
27
  `defineService` uses the owning package's name, version, and default executable.
27
28
  Use `command.binName` when the package has multiple executable entries. Set
28
29
  `command.executable` to run an existing external program instead of compiling a
29
- package entrypoint.
30
+ package entrypoint. Managed commands default `NODE_ENV` to `production`; an
31
+ explicit `command.environment.NODE_ENV` overrides it.
32
+
33
+ Set `pythonPackage` when the compiled service command needs a Python runtime:
34
+
35
+ ```ts
36
+ defineService(import.meta.url, {
37
+ pythonPackage: { name: "example-runtime" },
38
+ command: { arguments: ["serve"] },
39
+ });
40
+ ```
41
+
42
+ During installation, the service creates an isolated uv environment under its
43
+ data directory, installs the Python distribution at the service version, and
44
+ sets `PYTHON` to that environment's interpreter. `pythonPackage.python` selects
45
+ the Python version uv manages and defaults to `3.11`. uv must be available on
46
+ `PATH` during installation. Uninstalling the service removes the environment
47
+ with the rest of the service-owned data.
48
+
49
+ `command.options` accepts either a concrete option object or a Zod object
50
+ schema. Objects serialize their current values. Schemas parse `{}` and serialize
51
+ their defaults. Boolean values become positive or negated flags, arrays become
52
+ repeated flags, and `undefined` values are omitted:
53
+
54
+ ```ts
55
+ defineService(import.meta.url, {
56
+ command: {
57
+ arguments: ["serve"],
58
+ options: {
59
+ host: "127.0.0.1",
60
+ port: 4400,
61
+ telemetry: false,
62
+ },
63
+ },
64
+ });
65
+ ```
30
66
 
31
67
  ## Install And Manage The Service
32
68
 
@@ -69,69 +105,76 @@ reference uses `<cli>` as a placeholder for the consuming program's name.
69
105
 
70
106
  ### `<cli> service`
71
107
 
72
- ```text
73
- Usage: <cli> service [command]
74
-
75
108
  Install and manage the desktop service
76
109
 
77
- Commands:
78
- install [options] Install the service for the current user and start it
79
- start Start the installed service
80
- stop Stop the running service
81
- restart Restart the installed service
82
- status Print service installation and process state as JSON
83
- uninstall Stop and remove the service for the current user
110
+ ```sh
111
+ <cli> service [command]
84
112
  ```
85
113
 
86
- ### `<cli> service install`
114
+ #### Commands
87
115
 
88
- ```text
89
- Usage: <cli> service install [options]
116
+ | Command | Description |
117
+ | ------------------- | ----------------------------------------------------- |
118
+ | `install [options]` | Install the service for the current user and start it |
119
+ | `start` | Start the installed service |
120
+ | `stop` | Stop the running service |
121
+ | `restart` | Restart the installed service |
122
+ | `status` | Print service installation and process state as JSON |
123
+ | `uninstall` | Stop and remove the service for the current user |
124
+
125
+ ### `<cli> service install`
90
126
 
91
127
  Install the service for the current user and start it
92
128
 
93
- Options:
94
- --no-start install without starting the service
129
+ ```sh
130
+ <cli> service install [options]
95
131
  ```
96
132
 
97
- ### `<cli> service start`
133
+ #### Options
98
134
 
99
- ```text
100
- Usage: <cli> service start
135
+ | Option | Description |
136
+ | ------------ | ----------------------------------------------------------------- |
137
+ | `--start` | Start the service after installation. (default: true, env: START) |
138
+ | `--no-start` | Disable start the service after installation. |
139
+
140
+ ### `<cli> service start`
101
141
 
102
142
  Start the installed service
143
+
144
+ ```sh
145
+ <cli> service start
103
146
  ```
104
147
 
105
148
  ### `<cli> service stop`
106
149
 
107
- ```text
108
- Usage: <cli> service stop
109
-
110
150
  Stop the running service
151
+
152
+ ```sh
153
+ <cli> service stop
111
154
  ```
112
155
 
113
156
  ### `<cli> service restart`
114
157
 
115
- ```text
116
- Usage: <cli> service restart
117
-
118
158
  Restart the installed service
159
+
160
+ ```sh
161
+ <cli> service restart
119
162
  ```
120
163
 
121
164
  ### `<cli> service status`
122
165
 
123
- ```text
124
- Usage: <cli> service status
125
-
126
166
  Print service installation and process state as JSON
167
+
168
+ ```sh
169
+ <cli> service status
127
170
  ```
128
171
 
129
172
  ### `<cli> service uninstall`
130
173
 
131
- ```text
132
- Usage: <cli> service uninstall
133
-
134
174
  Stop and remove the service for the current user
175
+
176
+ ```sh
177
+ <cli> service uninstall
135
178
  ```
136
179
 
137
180
  <!-- cli-reference:end -->
package/index.ts CHANGED
@@ -3,13 +3,14 @@
3
3
  // Hand edits are overwritten on the next watch; this file is read-only.
4
4
 
5
5
  export const PACKAGE_IDENTIFIER = "@dbx-tools/cli-service";
6
- export const PACKAGE_VERSION = "0.9.40";
6
+ export const PACKAGE_VERSION = "0.9.46";
7
7
  export * as cli from "./src/cli.ts";
8
8
  export * as definition from "./src/definition.ts";
9
9
  export * as icon from "./src/icon.ts";
10
10
  export * as service from "./src/service.ts";
11
+ export { CliServiceInstallOptionsSchema } from "./src/cli.ts";
11
12
  export type { CliServiceDefinitionSource, CliServiceCliDependencies } from "./src/cli.ts";
12
- export { CliServiceCommandSchema, CliServiceMenuItemSchema, CliServiceDefinitionSchema } from "./src/definition.ts";
13
- export type { CliServiceCommand, CliServiceMenuItem, CliServiceDefinition, CliServiceDefinitionOptions } from "./src/definition.ts";
13
+ export { CliServiceCommandSchema, CliServiceMenuItemSchema, CliServicePythonPackageSchema, CliServiceDefinitionSchema } from "./src/definition.ts";
14
+ export type { CliServiceCommand, CliServiceCommandInput, CliServiceMenuItem, CliServicePythonPackage, CliServicePythonPackageInput, CliServiceDefinition, CliServiceDefinitionOptions } from "./src/definition.ts";
14
15
  export { CliService } from "./src/service.ts";
15
- export type { CliServiceCompiler, CliServiceRuntimeInstaller, CliServiceRuntimeOptions, CliServiceInstallOptions, CliServiceStatus, CliServiceLifecycle } from "./src/service.ts";
16
+ export type { CliServiceCompiler, CliServiceRuntimeInstaller, CliServicePythonInstaller, CliServiceRuntimeOptions, CliServiceStatus, CliServiceLifecycle } from "./src/service.ts";
package/lib/index.d.ts CHANGED
@@ -1,11 +1,12 @@
1
1
  export declare const PACKAGE_IDENTIFIER = "@dbx-tools/cli-service";
2
- export declare const PACKAGE_VERSION = "0.9.40";
2
+ export declare const PACKAGE_VERSION = "0.9.46";
3
3
  export * as cli from "./src/cli.ts";
4
4
  export * as definition from "./src/definition.ts";
5
5
  export * as icon from "./src/icon.ts";
6
6
  export * as service from "./src/service.ts";
7
+ export { CliServiceInstallOptionsSchema } from "./src/cli.ts";
7
8
  export type { CliServiceDefinitionSource, CliServiceCliDependencies } from "./src/cli.ts";
8
- export { CliServiceCommandSchema, CliServiceMenuItemSchema, CliServiceDefinitionSchema } from "./src/definition.ts";
9
- export type { CliServiceCommand, CliServiceMenuItem, CliServiceDefinition, CliServiceDefinitionOptions } from "./src/definition.ts";
9
+ export { CliServiceCommandSchema, CliServiceMenuItemSchema, CliServicePythonPackageSchema, CliServiceDefinitionSchema } from "./src/definition.ts";
10
+ export type { CliServiceCommand, CliServiceCommandInput, CliServiceMenuItem, CliServicePythonPackage, CliServicePythonPackageInput, CliServiceDefinition, CliServiceDefinitionOptions } from "./src/definition.ts";
10
11
  export { CliService } from "./src/service.ts";
11
- export type { CliServiceCompiler, CliServiceRuntimeInstaller, CliServiceRuntimeOptions, CliServiceInstallOptions, CliServiceStatus, CliServiceLifecycle } from "./src/service.ts";
12
+ export type { CliServiceCompiler, CliServiceRuntimeInstaller, CliServicePythonInstaller, CliServiceRuntimeOptions, CliServiceStatus, CliServiceLifecycle } from "./src/service.ts";
package/lib/index.js CHANGED
@@ -2,11 +2,12 @@
2
2
  // Regenerated from the exporting modules in ./src.
3
3
  // Hand edits are overwritten on the next watch; this file is read-only.
4
4
  export const PACKAGE_IDENTIFIER = "@dbx-tools/cli-service";
5
- export const PACKAGE_VERSION = "0.9.40";
5
+ export const PACKAGE_VERSION = "0.9.46";
6
6
  export * as cli from "./src/cli.js";
7
7
  export * as definition from "./src/definition.js";
8
8
  export * as icon from "./src/icon.js";
9
9
  export * as service from "./src/service.js";
10
- export { CliServiceCommandSchema, CliServiceMenuItemSchema, CliServiceDefinitionSchema } from "./src/definition.js";
10
+ export { CliServiceInstallOptionsSchema } from "./src/cli.js";
11
+ export { CliServiceCommandSchema, CliServiceMenuItemSchema, CliServicePythonPackageSchema, CliServiceDefinitionSchema } from "./src/definition.js";
11
12
  export { CliService } from "./src/service.js";
12
- //# sourceMappingURL=data:application/json;base64,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
13
+ //# sourceMappingURL=data:application/json;base64,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
@@ -1,2 +1,4 @@
1
1
  export declare function externalRuntimePackages(dependencies: Readonly<Record<string, string>>): string[];
2
2
  export declare function installServiceRuntime(bunExecutable: string, directory: string, dependencies: Readonly<Record<string, string>>): Promise<void>;
3
+ /** Create a clean uv environment and install one exact Python package. */
4
+ export declare function installServicePythonPackage(uvExecutable: string, directory: string, packageSpecifier: string, python: string, platform: NodeJS.Platform): Promise<string>;
@@ -1,4 +1,4 @@
1
- import { mkdir, readFile, writeFile } from "node:fs/promises";
1
+ import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
2
2
  import { join } from "node:path";
3
3
  import * as exec from "@dbx-tools/core/exec";
4
4
  export function externalRuntimePackages(dependencies) {
@@ -25,6 +25,24 @@ export async function installServiceRuntime(bunExecutable, directory, dependenci
25
25
  stderr: "capture",
26
26
  });
27
27
  }
28
+ /** Create a clean uv environment and install one exact Python package. */
29
+ export async function installServicePythonPackage(uvExecutable, directory, packageSpecifier, python, platform) {
30
+ await rm(directory, { recursive: true, force: true });
31
+ await exec.spawn(uvExecutable, ["venv", "--managed-python", "--no-project", "--python", python, directory], {
32
+ check: true,
33
+ stdin: "ignore",
34
+ stdout: "capture",
35
+ stderr: "capture",
36
+ });
37
+ const executable = join(directory, platform === "win32" ? "Scripts/python.exe" : "bin/python");
38
+ await exec.spawn(uvExecutable, ["pip", "install", "--python", executable, "--upgrade", packageSpecifier], {
39
+ check: true,
40
+ stdin: "ignore",
41
+ stdout: "capture",
42
+ stderr: "capture",
43
+ });
44
+ return executable;
45
+ }
28
46
  async function readOptionalRecord(path) {
29
47
  try {
30
48
  const value = JSON.parse(await readFile(path, "utf8"));
@@ -46,4 +64,4 @@ function stringRecord(value) {
46
64
  function isRecord(value) {
47
65
  return value !== null && typeof value === "object" && !Array.isArray(value);
48
66
  }
49
- //# sourceMappingURL=data:application/json;base64,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
67
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX3J1bnRpbWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvX3J1bnRpbWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLFNBQVMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFakMsT0FBTyxLQUFLLElBQUksTUFBTSxzQkFBc0IsQ0FBQztBQUU3QyxNQUFNLFVBQVUsdUJBQXVCLENBQUMsWUFBOEM7SUFDcEYsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUM7QUFDckYsQ0FBQztBQUVELE1BQU0sQ0FBQyxLQUFLLFVBQVUscUJBQXFCLENBQ3pDLGFBQXFCLEVBQ3JCLFNBQWlCLEVBQ2pCLFlBQThDO0lBRTlDLE1BQU0sS0FBSyxDQUFDLFNBQVMsRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQzVDLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxTQUFTLEVBQUUsY0FBYyxDQUFDLENBQUM7SUFDckQsTUFBTSxPQUFPLEdBQUcsTUFBTSxrQkFBa0IsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUN2RCxNQUFNLFNBQVMsQ0FDYixZQUFZLEVBQ1osR0FBRyxJQUFJLENBQUMsU0FBUyxDQUNmO1FBQ0UsR0FBRyxPQUFPO1FBQ1YsSUFBSSxFQUFFLDRCQUE0QjtRQUNsQyxPQUFPLEVBQUUsSUFBSTtRQUNiLFlBQVksRUFBRTtZQUNaLEdBQUcsWUFBWSxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUM7WUFDckMsR0FBRyxZQUFZO1NBQ2hCO0tBQ0YsRUFDRCxJQUFJLEVBQ0osQ0FBQyxDQUNGLElBQUksRUFDTCxNQUFNLENBQ1AsQ0FBQztJQUNGLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxhQUFhLEVBQUUsQ0FBQyxTQUFTLEVBQUUsY0FBYyxFQUFFLE9BQU8sRUFBRSxTQUFTLENBQUMsRUFBRTtRQUMvRSxLQUFLLEVBQUUsSUFBSTtRQUNYLEdBQUcsRUFBRSxTQUFTO1FBQ2QsS0FBSyxFQUFFLFFBQVE7UUFDZixNQUFNLEVBQUUsU0FBUztRQUNqQixNQUFNLEVBQUUsU0FBUztLQUNsQixDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQsMEVBQTBFO0FBQzFFLE1BQU0sQ0FBQyxLQUFLLFVBQVUsMkJBQTJCLENBQy9DLFlBQW9CLEVBQ3BCLFNBQWlCLEVBQ2pCLGdCQUF3QixFQUN4QixNQUFjLEVBQ2QsUUFBeUI7SUFFekIsTUFBTSxFQUFFLENBQUMsU0FBUyxFQUFFLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUN0RCxNQUFNLElBQUksQ0FBQyxLQUFLLENBQ2QsWUFBWSxFQUNaLENBQUMsTUFBTSxFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLFNBQVMsQ0FBQyxFQUMzRTtRQUNFLEtBQUssRUFBRSxJQUFJO1FBQ1gsS0FBSyxFQUFFLFFBQVE7UUFDZixNQUFNLEVBQUUsU0FBUztRQUNqQixNQUFNLEVBQUUsU0FBUztLQUNsQixDQUNGLENBQUM7SUFDRixNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsU0FBUyxFQUFFLFFBQVEsS0FBSyxPQUFPLENBQUMsQ0FBQyxDQUFDLG9CQUFvQixDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUMvRixNQUFNLElBQUksQ0FBQyxLQUFLLENBQ2QsWUFBWSxFQUNaLENBQUMsS0FBSyxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxnQkFBZ0IsQ0FBQyxFQUN6RTtRQUNFLEtBQUssRUFBRSxJQUFJO1FBQ1gsS0FBSyxFQUFFLFFBQVE7UUFDZixNQUFNLEVBQUUsU0FBUztRQUNqQixNQUFNLEVBQUUsU0FBUztLQUNsQixDQUNGLENBQUM7SUFDRixPQUFPLFVBQVUsQ0FBQztBQUNwQixDQUFDO0FBRUQsS0FBSyxVQUFVLGtCQUFrQixDQUFDLElBQVk7SUFDNUMsSUFBSSxDQUFDO1FBQ0gsTUFBTSxLQUFLLEdBQVksSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLFFBQVEsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUNoRSxJQUFJLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQztZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsK0JBQStCLElBQUksRUFBRSxDQUFDLENBQUM7UUFDN0UsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztRQUNmLElBQUssS0FBK0IsQ0FBQyxJQUFJLEtBQUssUUFBUTtZQUFFLE9BQU8sRUFBRSxDQUFDO1FBQ2xFLE1BQU0sS0FBSyxDQUFDO0lBQ2QsQ0FBQztBQUNILENBQUM7QUFFRCxTQUFTLFlBQVksQ0FBQyxLQUFjO0lBQ2xDLElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDO1FBQUUsT0FBTyxFQUFFLENBQUM7SUFDaEMsT0FBTyxNQUFNLENBQUMsV0FBVyxDQUN2QixNQUFNLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLE1BQU0sQ0FDMUIsQ0FBQyxLQUFLLEVBQTZCLEVBQUUsQ0FBQyxPQUFPLEtBQUssQ0FBQyxDQUFDLENBQUMsS0FBSyxRQUFRLENBQ25FLENBQ0YsQ0FBQztBQUNKLENBQUM7QUFFRCxTQUFTLFFBQVEsQ0FBQyxLQUFjO0lBQzlCLE9BQU8sS0FBSyxLQUFLLElBQUksSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQzlFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBta2RpciwgcmVhZEZpbGUsIHJtLCB3cml0ZUZpbGUgfSBmcm9tIFwibm9kZTpmcy9wcm9taXNlc1wiO1xuaW1wb3J0IHsgam9pbiB9IGZyb20gXCJub2RlOnBhdGhcIjtcblxuaW1wb3J0ICogYXMgZXhlYyBmcm9tIFwiQGRieC10b29scy9jb3JlL2V4ZWNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIGV4dGVybmFsUnVudGltZVBhY2thZ2VzKGRlcGVuZGVuY2llczogUmVhZG9ubHk8UmVjb3JkPHN0cmluZywgc3RyaW5nPj4pOiBzdHJpbmdbXSB7XG4gIHJldHVybiBPYmplY3Qua2V5cyhkZXBlbmRlbmNpZXMpLmZpbHRlcigobmFtZSkgPT4gIW5hbWUuc3RhcnRzV2l0aChcIkBkYngtdG9vbHMvXCIpKTtcbn1cblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGluc3RhbGxTZXJ2aWNlUnVudGltZShcbiAgYnVuRXhlY3V0YWJsZTogc3RyaW5nLFxuICBkaXJlY3Rvcnk6IHN0cmluZyxcbiAgZGVwZW5kZW5jaWVzOiBSZWFkb25seTxSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+Pixcbik6IFByb21pc2U8dm9pZD4ge1xuICBhd2FpdCBta2RpcihkaXJlY3RvcnksIHsgcmVjdXJzaXZlOiB0cnVlIH0pO1xuICBjb25zdCBtYW5pZmVzdFBhdGggPSBqb2luKGRpcmVjdG9yeSwgXCJwYWNrYWdlLmpzb25cIik7XG4gIGNvbnN0IGN1cnJlbnQgPSBhd2FpdCByZWFkT3B0aW9uYWxSZWNvcmQobWFuaWZlc3RQYXRoKTtcbiAgYXdhaXQgd3JpdGVGaWxlKFxuICAgIG1hbmlmZXN0UGF0aCxcbiAgICBgJHtKU09OLnN0cmluZ2lmeShcbiAgICAgIHtcbiAgICAgICAgLi4uY3VycmVudCxcbiAgICAgICAgbmFtZTogXCJAZGJ4LXRvb2xzL3NlcnZpY2UtcnVudGltZVwiLFxuICAgICAgICBwcml2YXRlOiB0cnVlLFxuICAgICAgICBkZXBlbmRlbmNpZXM6IHtcbiAgICAgICAgICAuLi5zdHJpbmdSZWNvcmQoY3VycmVudC5kZXBlbmRlbmNpZXMpLFxuICAgICAgICAgIC4uLmRlcGVuZGVuY2llcyxcbiAgICAgICAgfSxcbiAgICAgIH0sXG4gICAgICBudWxsLFxuICAgICAgMixcbiAgICApfVxcbmAsXG4gICAgXCJ1dGY4XCIsXG4gICk7XG4gIGF3YWl0IGV4ZWMuc3Bhd24oYnVuRXhlY3V0YWJsZSwgW1wiaW5zdGFsbFwiLCBcIi0tcHJvZHVjdGlvblwiLCBcIi0tY3dkXCIsIGRpcmVjdG9yeV0sIHtcbiAgICBjaGVjazogdHJ1ZSxcbiAgICBjd2Q6IGRpcmVjdG9yeSxcbiAgICBzdGRpbjogXCJpZ25vcmVcIixcbiAgICBzdGRvdXQ6IFwiY2FwdHVyZVwiLFxuICAgIHN0ZGVycjogXCJjYXB0dXJlXCIsXG4gIH0pO1xufVxuXG4vKiogQ3JlYXRlIGEgY2xlYW4gdXYgZW52aXJvbm1lbnQgYW5kIGluc3RhbGwgb25lIGV4YWN0IFB5dGhvbiBwYWNrYWdlLiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGluc3RhbGxTZXJ2aWNlUHl0aG9uUGFja2FnZShcbiAgdXZFeGVjdXRhYmxlOiBzdHJpbmcsXG4gIGRpcmVjdG9yeTogc3RyaW5nLFxuICBwYWNrYWdlU3BlY2lmaWVyOiBzdHJpbmcsXG4gIHB5dGhvbjogc3RyaW5nLFxuICBwbGF0Zm9ybTogTm9kZUpTLlBsYXRmb3JtLFxuKTogUHJvbWlzZTxzdHJpbmc+IHtcbiAgYXdhaXQgcm0oZGlyZWN0b3J5LCB7IHJlY3Vyc2l2ZTogdHJ1ZSwgZm9yY2U6IHRydWUgfSk7XG4gIGF3YWl0IGV4ZWMuc3Bhd24oXG4gICAgdXZFeGVjdXRhYmxlLFxuICAgIFtcInZlbnZcIiwgXCItLW1hbmFnZWQtcHl0aG9uXCIsIFwiLS1uby1wcm9qZWN0XCIsIFwiLS1weXRob25cIiwgcHl0aG9uLCBkaXJlY3RvcnldLFxuICAgIHtcbiAgICAgIGNoZWNrOiB0cnVlLFxuICAgICAgc3RkaW46IFwiaWdub3JlXCIsXG4gICAgICBzdGRvdXQ6IFwiY2FwdHVyZVwiLFxuICAgICAgc3RkZXJyOiBcImNhcHR1cmVcIixcbiAgICB9LFxuICApO1xuICBjb25zdCBleGVjdXRhYmxlID0gam9pbihkaXJlY3RvcnksIHBsYXRmb3JtID09PSBcIndpbjMyXCIgPyBcIlNjcmlwdHMvcHl0aG9uLmV4ZVwiIDogXCJiaW4vcHl0aG9uXCIpO1xuICBhd2FpdCBleGVjLnNwYXduKFxuICAgIHV2RXhlY3V0YWJsZSxcbiAgICBbXCJwaXBcIiwgXCJpbnN0YWxsXCIsIFwiLS1weXRob25cIiwgZXhlY3V0YWJsZSwgXCItLXVwZ3JhZGVcIiwgcGFja2FnZVNwZWNpZmllcl0sXG4gICAge1xuICAgICAgY2hlY2s6IHRydWUsXG4gICAgICBzdGRpbjogXCJpZ25vcmVcIixcbiAgICAgIHN0ZG91dDogXCJjYXB0dXJlXCIsXG4gICAgICBzdGRlcnI6IFwiY2FwdHVyZVwiLFxuICAgIH0sXG4gICk7XG4gIHJldHVybiBleGVjdXRhYmxlO1xufVxuXG5hc3luYyBmdW5jdGlvbiByZWFkT3B0aW9uYWxSZWNvcmQocGF0aDogc3RyaW5nKTogUHJvbWlzZTxSZWNvcmQ8c3RyaW5nLCB1bmtub3duPj4ge1xuICB0cnkge1xuICAgIGNvbnN0IHZhbHVlOiB1bmtub3duID0gSlNPTi5wYXJzZShhd2FpdCByZWFkRmlsZShwYXRoLCBcInV0ZjhcIikpO1xuICAgIGlmICghaXNSZWNvcmQodmFsdWUpKSB0aHJvdyBuZXcgRXJyb3IoYEpTT04gZmlsZSBpcyBub3QgYW4gb2JqZWN0OiAke3BhdGh9YCk7XG4gICAgcmV0dXJuIHZhbHVlO1xuICB9IGNhdGNoIChlcnJvcikge1xuICAgIGlmICgoZXJyb3IgYXMgTm9kZUpTLkVycm5vRXhjZXB0aW9uKS5jb2RlID09PSBcIkVOT0VOVFwiKSByZXR1cm4ge307XG4gICAgdGhyb3cgZXJyb3I7XG4gIH1cbn1cblxuZnVuY3Rpb24gc3RyaW5nUmVjb3JkKHZhbHVlOiB1bmtub3duKTogUmVjb3JkPHN0cmluZywgc3RyaW5nPiB7XG4gIGlmICghaXNSZWNvcmQodmFsdWUpKSByZXR1cm4ge307XG4gIHJldHVybiBPYmplY3QuZnJvbUVudHJpZXMoXG4gICAgT2JqZWN0LmVudHJpZXModmFsdWUpLmZpbHRlcihcbiAgICAgIChlbnRyeSk6IGVudHJ5IGlzIFtzdHJpbmcsIHN0cmluZ10gPT4gdHlwZW9mIGVudHJ5WzFdID09PSBcInN0cmluZ1wiLFxuICAgICksXG4gICk7XG59XG5cbmZ1bmN0aW9uIGlzUmVjb3JkKHZhbHVlOiB1bmtub3duKTogdmFsdWUgaXMgUmVjb3JkPHN0cmluZywgdW5rbm93bj4ge1xuICByZXR1cm4gdmFsdWUgIT09IG51bGwgJiYgdHlwZW9mIHZhbHVlID09PSBcIm9iamVjdFwiICYmICFBcnJheS5pc0FycmF5KHZhbHVlKTtcbn1cbiJdfQ==
package/lib/src/cli.d.ts CHANGED
@@ -7,6 +7,7 @@
7
7
  * @module
8
8
  */
9
9
  import { Command } from "commander";
10
+ import { z } from "zod";
10
11
  import type { CliServiceDefinition } from "./definition.ts";
11
12
  import { type CliServiceLifecycle } from "./service.ts";
12
13
  /** Static definition or action-time factory used by a service command group. */
@@ -18,5 +19,9 @@ export interface CliServiceCliDependencies {
18
19
  /** Write the JSON result of the status command. */
19
20
  write(value: string): void;
20
21
  }
22
+ export declare const CliServiceInstallOptionsSchema: z.ZodObject<{
23
+ start: z.ZodDefault<z.ZodBoolean>;
24
+ }, z.core.$strict>;
25
+ export type CliServiceInstallOptions = z.output<typeof CliServiceInstallOptionsSchema>;
21
26
  /** Build install, start, stop, restart, status, and uninstall commands for a service. */
22
27
  export declare function buildServiceCommand(source: CliServiceDefinitionSource, dependencies?: CliServiceCliDependencies): Command;
package/lib/src/cli.js CHANGED
@@ -6,12 +6,20 @@
6
6
  *
7
7
  * @module
8
8
  */
9
+ import { addArgs, parseArgs } from "@dbx-tools/cli-args/args";
9
10
  import { Command } from "commander";
11
+ import { z } from "zod";
10
12
  import { CliService } from "./service.js";
11
13
  const DEFAULT_DEPENDENCIES = {
12
14
  create: (definition) => new CliService(definition),
13
15
  write: (value) => process.stdout.write(value),
14
16
  };
17
+ export const CliServiceInstallOptionsSchema = z
18
+ .object({
19
+ start: z.boolean().default(true).describe("Start the service after installation."),
20
+ })
21
+ .strict()
22
+ .describe("Options for installing a current-user CLI service.");
15
23
  /** Build install, start, stop, restart, status, and uninstall commands for a service. */
16
24
  export function buildServiceCommand(source, dependencies = DEFAULT_DEPENDENCIES) {
17
25
  const definition = resolveDefinition(source);
@@ -19,11 +27,9 @@ export function buildServiceCommand(source, dependencies = DEFAULT_DEPENDENCIES)
19
27
  const command = new Command("service").description(typeof source === "function"
20
28
  ? "Install and manage the desktop service"
21
29
  : `Install and manage the ${source.name} desktop service`);
22
- command
23
- .command("install")
24
- .description("Install the service for the current user and start it")
25
- .option("--no-start", "install without starting the service")
26
- .action(async (options) => {
30
+ const install = addArgs(command.command("install").description("Install the service for the current user and start it"), CliServiceInstallOptionsSchema);
31
+ install.action(async () => {
32
+ const options = parseArgs(install, CliServiceInstallOptionsSchema);
27
33
  await service().install({ start: options.start });
28
34
  });
29
35
  command
@@ -61,4 +67,4 @@ export function buildServiceCommand(source, dependencies = DEFAULT_DEPENDENCIES)
61
67
  function resolveDefinition(source) {
62
68
  return typeof source === "function" ? source : () => source;
63
69
  }
64
- //# sourceMappingURL=data:application/json;base64,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
70
+ //# sourceMappingURL=data:application/json;base64,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
@@ -7,6 +7,7 @@
7
7
  *
8
8
  * @module
9
9
  */
10
+ import { type ArgumentSource } from "@dbx-tools/cli-args/args";
10
11
  import { z } from "zod";
11
12
  /** A process launched by the system-tray service host. */
12
13
  export declare const CliServiceCommandSchema: z.ZodReadonly<z.ZodObject<{
@@ -19,6 +20,13 @@ export declare const CliServiceCommandSchema: z.ZodReadonly<z.ZodObject<{
19
20
  }, z.core.$strip>>;
20
21
  /** A process launched by the system-tray service host. */
21
22
  export type CliServiceCommand = z.infer<typeof CliServiceCommandSchema>;
23
+ /** Command input accepted by {@link defineService} before option serialization. */
24
+ export type CliServiceCommandInput = Omit<CliServiceCommand, "arguments"> & {
25
+ /** Positional or pre-serialized arguments placed before generated options. */
26
+ readonly arguments?: readonly string[];
27
+ /** Zod defaults or concrete option values converted into CLI flags. */
28
+ readonly options?: ArgumentSource;
29
+ };
22
30
  /** A typed custom item inserted between the default service title and Quit item. */
23
31
  export declare const CliServiceMenuItemSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
24
32
  type: z.ZodLiteral<"separator">;
@@ -40,6 +48,16 @@ export declare const CliServiceMenuItemSchema: z.ZodDiscriminatedUnion<[z.ZodRea
40
48
  }, z.core.$strip>>], "type">;
41
49
  /** A typed custom item inserted between the default service title and Quit item. */
42
50
  export type CliServiceMenuItem = z.infer<typeof CliServiceMenuItemSchema>;
51
+ /** Python package installed into a service-owned uv environment. */
52
+ export declare const CliServicePythonPackageSchema: z.ZodReadonly<z.ZodObject<{
53
+ name: z.ZodString;
54
+ version: z.ZodOptional<z.ZodString>;
55
+ python: z.ZodDefault<z.ZodString>;
56
+ }, z.core.$strip>>;
57
+ /** Python package installed into a service-owned uv environment. */
58
+ export type CliServicePythonPackage = z.infer<typeof CliServicePythonPackageSchema>;
59
+ /** Python package input accepted before the default Python version is applied. */
60
+ export type CliServicePythonPackageInput = z.input<typeof CliServicePythonPackageSchema>;
43
61
  /** Complete serializable definition consumed by the lifecycle manager and tray host. */
44
62
  export declare const CliServiceDefinitionSchema: z.ZodReadonly<z.ZodObject<{
45
63
  id: z.ZodString;
@@ -49,6 +67,11 @@ export declare const CliServiceDefinitionSchema: z.ZodReadonly<z.ZodObject<{
49
67
  icon: z.ZodString;
50
68
  isTemplateIcon: z.ZodOptional<z.ZodBoolean>;
51
69
  dataDirectory: z.ZodOptional<z.ZodString>;
70
+ pythonPackage: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
71
+ name: z.ZodString;
72
+ version: z.ZodOptional<z.ZodString>;
73
+ python: z.ZodDefault<z.ZodString>;
74
+ }, z.core.$strip>>>;
52
75
  command: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
53
76
  executable: z.ZodOptional<z.ZodString>;
54
77
  entrypoint: z.ZodOptional<z.ZodString>;
@@ -79,7 +102,12 @@ export declare const CliServiceDefinitionSchema: z.ZodReadonly<z.ZodObject<{
79
102
  /** Complete serializable definition consumed by the lifecycle manager and tray host. */
80
103
  export type CliServiceDefinition = z.infer<typeof CliServiceDefinitionSchema>;
81
104
  /** Package-derived service fields plus caller-owned icon, process, and menu options. */
82
- export type CliServiceDefinitionOptions = Omit<CliServiceDefinition, "packageName" | "id" | "name" | "version" | "icon" | "isTemplateIcon"> & Partial<Pick<CliServiceDefinition, "id" | "name" | "version" | "icon" | "isTemplateIcon">>;
105
+ export type CliServiceDefinitionOptions = Omit<CliServiceDefinition, "packageName" | "id" | "name" | "version" | "icon" | "isTemplateIcon" | "pythonPackage" | "command"> & Partial<Pick<CliServiceDefinition, "id" | "name" | "version" | "icon" | "isTemplateIcon">> & {
106
+ /** Python package installed into a service-owned uv environment. */
107
+ readonly pythonPackage?: CliServicePythonPackageInput;
108
+ /** Service process command with optional schema or object-backed options. */
109
+ readonly command?: CliServiceCommandInput;
110
+ };
83
111
  /** Define a service from an owning module URL or installed package name. */
84
112
  export declare function defineService(packageReference: string, options: CliServiceDefinitionOptions): CliServiceDefinition;
85
113
  /** Resolve a package's single or explicitly named executable entrypoint. */
@@ -7,6 +7,7 @@
7
7
  *
8
8
  * @module
9
9
  */
10
+ import { serializeArgs } from "@dbx-tools/cli-args/args";
10
11
  import { z } from "zod";
11
12
  import { resolveServicePackage, servicePackageDefaults } from "./_package.js";
12
13
  import { serviceTrayIcon } from "./icon.js";
@@ -59,6 +60,23 @@ export const CliServiceMenuItemSchema = z.discriminatedUnion("type", [
59
60
  })
60
61
  .readonly(),
61
62
  ]);
63
+ /** Python package installed into a service-owned uv environment. */
64
+ export const CliServicePythonPackageSchema = z
65
+ .object({
66
+ name: z.string().min(1).describe("Python distribution name installed by uv."),
67
+ version: z
68
+ .string()
69
+ .min(1)
70
+ .optional()
71
+ .describe("Python distribution version. Defaults to the service package version."),
72
+ python: z
73
+ .string()
74
+ .min(1)
75
+ .default("3.11")
76
+ .describe("Python version request passed to uv when creating the environment."),
77
+ })
78
+ .readonly()
79
+ .describe("Python runtime package installed with uv for a managed service.");
62
80
  /** Complete serializable definition consumed by the lifecycle manager and tray host. */
63
81
  export const CliServiceDefinitionSchema = z
64
82
  .object({
@@ -73,6 +91,7 @@ export const CliServiceDefinitionSchema = z
73
91
  icon: z.string().min(1),
74
92
  isTemplateIcon: z.boolean().optional(),
75
93
  dataDirectory: z.string().min(1).optional(),
94
+ pythonPackage: CliServicePythonPackageSchema.optional().describe("Python runtime package installed into a service-owned uv environment."),
76
95
  command: CliServiceCommandSchema.optional(),
77
96
  menu: z.array(CliServiceMenuItemSchema).readonly().optional(),
78
97
  })
@@ -81,18 +100,34 @@ export const CliServiceDefinitionSchema = z
81
100
  export function defineService(packageReference, options) {
82
101
  const pkg = resolveServicePackage(packageReference);
83
102
  const defaults = servicePackageDefaults(pkg);
103
+ const { command, ...definition } = options;
84
104
  return CliServiceDefinitionSchema.parse({
85
- ...options,
105
+ ...definition,
106
+ command: resolveServiceCommand(command),
86
107
  packageName: pkg.name,
87
- id: options.id ?? defaults.id,
88
- name: options.name ?? defaults.name,
89
- version: options.version ?? pkg.version,
90
- icon: options.icon ?? serviceTrayIcon(),
91
- isTemplateIcon: options.isTemplateIcon ?? process.platform === "darwin",
108
+ id: definition.id ?? defaults.id,
109
+ name: definition.name ?? defaults.name,
110
+ version: definition.version ?? pkg.version,
111
+ icon: definition.icon ?? serviceTrayIcon(),
112
+ isTemplateIcon: definition.isTemplateIcon ?? process.platform === "darwin",
113
+ });
114
+ }
115
+ function resolveServiceCommand(command) {
116
+ if (!command)
117
+ return undefined;
118
+ const { options, ...definition } = command;
119
+ const arguments_ = [
120
+ ...(definition.arguments ?? []),
121
+ ...(options === undefined ? [] : serializeArgs(options)),
122
+ ];
123
+ return CliServiceCommandSchema.parse({
124
+ ...definition,
125
+ environment: { NODE_ENV: "production", ...definition.environment },
126
+ ...(arguments_.length > 0 ? { arguments: arguments_ } : {}),
92
127
  });
93
128
  }
94
129
  /** Resolve a package's single or explicitly named executable entrypoint. */
95
130
  export function resolveServicePackageBin(packageReference, binName) {
96
131
  return resolveServicePackage(packageReference).bin(binName);
97
132
  }
98
- //# 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 { 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"]}
133
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../src/definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,aAAa,EAAuB,MAAM,0BAA0B,CAAC;AAC9E,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;AAad,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,oEAAoE;AACpE,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC;KAC3C,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,2CAA2C,CAAC;IAC7E,OAAO,EAAE,CAAC;SACP,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,EAAE;SACV,QAAQ,CAAC,uEAAuE,CAAC;IACpF,MAAM,EAAE,CAAC;SACN,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,OAAO,CAAC,MAAM,CAAC;SACf,QAAQ,CAAC,oEAAoE,CAAC;CAClF,CAAC;KACD,QAAQ,EAAE;KACV,QAAQ,CAAC,iEAAiE,CAAC,CAAC;AAQ/E,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,aAAa,EAAE,6BAA6B,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAC9D,uEAAuE,CACxE;IACD,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;AAwBd,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,MAAM,EAAE,OAAO,EAAE,GAAG,UAAU,EAAE,GAAG,OAAO,CAAC;IAC3C,OAAO,0BAA0B,CAAC,KAAK,CAAC;QACtC,GAAG,UAAU;QACb,OAAO,EAAE,qBAAqB,CAAC,OAAO,CAAC;QACvC,WAAW,EAAE,GAAG,CAAC,IAAI;QACrB,EAAE,EAAE,UAAU,CAAC,EAAE,IAAI,QAAQ,CAAC,EAAE;QAChC,IAAI,EAAE,UAAU,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI;QACtC,OAAO,EAAE,UAAU,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO;QAC1C,IAAI,EAAE,UAAU,CAAC,IAAI,IAAI,eAAe,EAAE;QAC1C,cAAc,EAAE,UAAU,CAAC,cAAc,IAAI,OAAO,CAAC,QAAQ,KAAK,QAAQ;KAC3E,CAAC,CAAC;AACL,CAAC;AAED,SAAS,qBAAqB,CAC5B,OAA2C;IAE3C,IAAI,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IAC/B,MAAM,EAAE,OAAO,EAAE,GAAG,UAAU,EAAE,GAAG,OAAO,CAAC;IAC3C,MAAM,UAAU,GAAG;QACjB,GAAG,CAAC,UAAU,CAAC,SAAS,IAAI,EAAE,CAAC;QAC/B,GAAG,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;KACzD,CAAC;IACF,OAAO,uBAAuB,CAAC,KAAK,CAAC;QACnC,GAAG,UAAU;QACb,WAAW,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,UAAU,CAAC,WAAW,EAAE;QAClE,GAAG,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC5D,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 { 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/** Python package installed into a service-owned uv environment. */\nexport const CliServicePythonPackageSchema = z\n  .object({\n    name: z.string().min(1).describe(\"Python distribution name installed by uv.\"),\n    version: z\n      .string()\n      .min(1)\n      .optional()\n      .describe(\"Python distribution version. Defaults to the service package version.\"),\n    python: z\n      .string()\n      .min(1)\n      .default(\"3.11\")\n      .describe(\"Python version request passed to uv when creating the environment.\"),\n  })\n  .readonly()\n  .describe(\"Python runtime package installed with uv for a managed service.\");\n\n/** Python package installed into a service-owned uv environment. */\nexport type CliServicePythonPackage = z.infer<typeof CliServicePythonPackageSchema>;\n\n/** Python package input accepted before the default Python version is applied. */\nexport type CliServicePythonPackageInput = z.input<typeof CliServicePythonPackageSchema>;\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    pythonPackage: CliServicePythonPackageSchema.optional().describe(\n      \"Python runtime package installed into a service-owned uv environment.\",\n    ),\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\"\n  | \"id\"\n  | \"name\"\n  | \"version\"\n  | \"icon\"\n  | \"isTemplateIcon\"\n  | \"pythonPackage\"\n  | \"command\"\n> &\n  Partial<Pick<CliServiceDefinition, \"id\" | \"name\" | \"version\" | \"icon\" | \"isTemplateIcon\">> & {\n    /** Python package installed into a service-owned uv environment. */\n    readonly pythonPackage?: CliServicePythonPackageInput;\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"]}