@dovocode/workstation 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,525 @@
+type Platform = "darwin" | "linux";
+type PackageManager = "mise" | "brew" | "brew-cask" | "apt" | "system";
+/** Homebrew cask upgrade behavior. */
+interface BrewCaskUpgradeOptions {
+    /** Include auto-updating casks and refresh their lock pins on each run. */
+    readonly greedy?: boolean;
+    /** Pass --force when upgrading a cask; does not by itself trigger an upgrade. */
+    readonly force?: boolean;
+}
+/** Machine and path information passed to a configuration factory. */
+interface Context {
+    /** Short hostname by default, or the exact `--machine` override. */
+    readonly machine: string;
+    /** Full operating-system hostname. */
+    readonly hostname: string;
+    /** Operating system detected on the executing machine. */
+    readonly platform: Platform;
+    /** Absolute home directory of the executing user. */
+    readonly home: string;
+    /** Absolute directory of the TypeScript entry point; imported fragments share this base. */
+    readonly configDir: string;
+}
+interface PackageResource {
+    readonly kind: "package";
+    readonly manager: PackageManager;
+    readonly name: string;
+    readonly version?: string;
+    readonly upgrade?: BrewCaskUpgradeOptions;
+}
+interface ResolvedPackageResource extends PackageResource {
+    /** Concrete version resolved into workstation.lock. */
+    readonly lockedVersion?: string;
+}
+interface SymlinkResource {
+    readonly kind: "symlink";
+    readonly source: string;
+    readonly target: string;
+}
+interface LaunchAgentResource {
+    readonly kind: "launch-agent";
+    readonly label: string;
+    readonly program: string;
+    readonly args?: readonly string[];
+    readonly environment?: Readonly<Record<string, string>>;
+    readonly runAtLoad?: boolean;
+    readonly keepAlive?: boolean;
+    readonly stdoutPath?: string;
+    readonly stderrPath?: string;
+}
+type StructuredFormat = "toml" | "yaml" | "json" | "jsonc" | "zsh" | "bash";
+/** `overwrite` saves and replaces unmanaged files; `update` rejects unmanaged differences; `ignore` preserves existing targets. */
+type IfExistsPolicy = "update" | "overwrite" | "ignore";
+type ConfigValue = string | number | boolean | null | readonly ConfigValue[] | Readonly<{
+    [key: string]: ConfigValue;
+}>;
+interface GeneratedFileResource {
+    /** Pre-rendered JSONC from the typed builder. Used only with format jsonc. */
+    readonly renderedContent?: string;
+    readonly kind: "generated-file";
+    readonly target: string;
+    readonly format: StructuredFormat;
+    readonly value: ConfigValue;
+    readonly ifExists: IfExistsPolicy;
+    readonly mode?: number;
+}
+type SystemdScope = "user" | "system";
+interface SystemdServiceResource {
+    readonly kind: "systemd-service";
+    readonly name: string;
+    readonly description?: string;
+    readonly program: string;
+    readonly args?: readonly string[];
+    readonly environment?: Readonly<Record<string, string>>;
+    readonly restart?: "no" | "on-failure" | "always";
+    readonly wantedBy?: string;
+    readonly scope: SystemdScope;
+}
+/** Run a program directly, without an implicit shell. Custom builds expand {source}, {output}, and {target}. */
+interface CommandSpec {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string;
+    readonly environment?: Readonly<Record<string, string>>;
+}
+/** A named direct command with a description shown by --list-tasks. */
+interface TaskDefinition extends CommandSpec {
+    readonly description?: string;
+}
+interface CustomToolResource {
+    readonly kind: "custom-tool";
+    readonly name: string;
+    readonly source: string;
+    readonly sourceHash?: string;
+    readonly target: string;
+    readonly build: CommandSpec;
+}
+type Resource = PackageResource | SymlinkResource | LaunchAgentResource | GeneratedFileResource | SystemdServiceResource | CustomToolResource;
+/** One resource or nested arrays. False, null, and undefined are ignored. */
+type ResourceInput = Resource | readonly ResourceInput[] | false | null | undefined;
+/** A composable configuration fragment. Prefer the exported helpers to constructing resources manually. */
+interface ConfigDefinition {
+    /** Named commands executed explicitly with workstation <task>. */
+    readonly tasks?: Readonly<Record<string, TaskDefinition>>;
+    /** Alternate task names; alias chains are supported and cycles rejected. */
+    readonly aliases?: Readonly<Record<string, string>>;
+    /** Default package manager for tools.system on each platform. */
+    readonly managers?: Partial<Record<Platform, Exclude<PackageManager, "system">>>;
+    /** Shared resource declarations, evaluated in order. */
+    readonly resources?: ResourceInput;
+    /** Additional resources keyed by exact machine name. */
+    readonly machines?: Readonly<Record<string, ResourceInput>>;
+    /** Local ownership/backup state path. Defaults to ~/.local/state/workstation/state.json; do not commit it. */
+    readonly stateFile?: string;
+}
+/** A fragment, factory, or nested array of fragments; absent fragments are ignored. */
+type ConfigInput = ConfigDefinition | ConfigFactory | readonly ConfigInput[] | false | null | undefined;
+/** Compute a configuration fragment using the current machine context. */
+type ConfigFactory = (context: Context) => ConfigInput;
+/** Accepted default export from workstation.config.ts. */
+type WorkstationConfig = ConfigInput;
+interface ResolvedConfig {
+    readonly tasks?: Readonly<Record<string, TaskDefinition>>;
+    readonly aliases?: Readonly<Record<string, string>>;
+    readonly context: Context;
+    readonly resources: readonly ResolvedResource[];
+    readonly stateFile: string;
+}
+type ResolvedResource = ResolvedPackageResource | Exclude<Resource, PackageResource>;
+type OriginalFile = {
+    readonly kind: "file";
+    readonly content: string;
+    readonly mode: number;
+} | {
+    readonly kind: "symlink";
+    readonly target: string;
+};
+interface StateEntry {
+    readonly id: string;
+    readonly fingerprint: string;
+    readonly owned: boolean;
+    readonly resource: ResolvedResource;
+    readonly installedVersion?: string;
+    readonly installedHash?: string;
+    readonly originalFile?: OriginalFile;
+}
+interface WorkstationState {
+    readonly version: 1;
+    readonly machine: string;
+    readonly resources: Readonly<Record<string, StateEntry>>;
+}
+type ActionType = "create" | "adopt" | "update" | "remove" | "forget";
+interface Action {
+    readonly type: ActionType;
+    readonly id: string;
+    readonly resource: ResolvedResource;
+    readonly previous?: StateEntry;
+    readonly reason: string;
+}
+interface CommandResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Command execution boundary, replaceable in tests or embedded integrations. */
+interface Runner {
+    /** Execute a command directly and return captured output and its exit code; spawn failures reject. */
+    run(command: string, args: readonly string[], options?: RunOptions): Promise<CommandResult>;
+}
+interface RunOptions {
+    readonly cwd?: string;
+    readonly environment?: Readonly<Record<string, string>>;
+}
+
+/** A JSONC value with comments, ready to pass to files.jsonc. */
+declare class JsoncDocument {
+    readonly content: string;
+    /** Store the rendered document text; callers construct documents through the builder commands. */
+    private constructor();
+    /** @internal Build from typed commands; arbitrary unvalidated JSONC is not accepted. */
+    static from(lines: readonly JsoncLine[]): JsoncDocument;
+}
+/** One JSONC builder instruction. Prefer the jsonc helpers to constructing instructions manually. */
+type JsoncCommand = {
+    readonly kind: "comment";
+    readonly text: string;
+} | {
+    readonly kind: "blank";
+} | {
+    readonly kind: "value";
+    readonly content: string;
+} | {
+    readonly kind: "property";
+    readonly name: string;
+    readonly content: string;
+};
+/** A builder command or nested group. Absent/disabled groups are ignored. */
+type JsoncLine = JsoncCommand | JsoncDocument | readonly JsoncLine[] | false | null | undefined;
+/** Compose JSONC line by line with comments; punctuation and escaping are generated. */
+declare const jsonc: {
+    /** Join a document's comments and single root value, separating commands by newlines.
+     * @example jsonc.concat(jsonc.comment("Editor settings"), jsonc.object([jsonc.property("theme", "dark")]))
+     */
+    concat(...lines: readonly JsoncLine[]): JsoncDocument;
+    /** Add a // comment. Each line of multiline text receives its own comment prefix. */
+    comment(text: string): JsoncCommand;
+    /** Insert an intentional empty line. */
+    blank(): JsoncCommand;
+    /** Add an object property. Values may be ordinary JSON data or a nested JSONC document. */
+    property(name: string, value: ConfigValue | JsoncDocument): JsoncCommand;
+    /** Add a JSON value, for example an array element or a primitive document root. */
+    value(value: ConfigValue | JsoncDocument): JsoncCommand;
+    /** Build an object from properties, comments, blank lines, and optional groups. */
+    object(lines: readonly JsoncLine[]): JsoncDocument;
+    /** Build an array from values, comments, blank lines, and optional groups. */
+    array(lines: readonly JsoncLine[]): JsoncDocument;
+};
+
+/** Declare a task command; arguments are passed directly without a shell.
+ * @example tasks: { test: task("pnpm", ["test"], { description: "Run tests" }) }
+ */
+declare function task(command: string, args?: readonly string[], options?: Omit<TaskDefinition, "command" | "args">): TaskDefinition;
+
+/** Run one explicit task or alias, appending CLI arguments without shell interpolation. */
+declare function runTask(config: ResolvedConfig, name: string, args: readonly string[], runner: Runner): Promise<CommandResult>;
+
+/** Declare packages; installation happens when the Workstation CLI runs. */
+declare const tools: {
+    /**
+     * Install mise tools. A list requests `latest`; a map accepts version selectors.
+     * @example tools.mise({ node: "lts", go: "1.27" })
+     */
+    mise: (packages: readonly string[] | Readonly<Record<string, string>>) => PackageResource[];
+    /** Install Homebrew formulae (command-line packages). */
+    brew: (packages: readonly string[]) => PackageResource[];
+    /**
+     * Install macOS applications. Greedy casks refresh their lock pin each run.
+     * @example tools.brewCask(["ghostty"], { greedy: true, force: true })
+     */
+    brewCask: (packages: readonly string[], upgrade?: BrewCaskUpgradeOptions) => PackageResource[];
+    /** Install Debian/Ubuntu packages through APT. Mutations request sudo. */
+    apt: (packages: readonly string[]) => PackageResource[];
+    /** Use the configured platform manager; defaults to Homebrew on macOS and APT on Linux. */
+    system: (packages: readonly string[]) => PackageResource[];
+};
+/**
+ * Link a config-relative source to a home-relative target. Absolute paths are supported.
+ * @example symlink("dotfiles/gitconfig", "~/.gitconfig")
+ */
+declare function symlink(source: string, target: string): SymlinkResource;
+/**
+ * Declare a macOS user LaunchAgent. Use inside `darwin(...)`.
+ * @param label Unique launchd label, for example `dev.example.worker`.
+ */
+declare function launchAgent(label: string, options: Omit<LaunchAgentResource, "kind" | "label">): LaunchAgentResource;
+/** Control how a generated file replaces existing content and its Unix permissions. */
+interface GeneratedFileOptions {
+    /** Existing-file policy. Defaults to `overwrite`, with the original saved for restoration. */
+    readonly ifExists?: IfExistsPolicy;
+    /** Unix permissions as an octal number. Defaults to `0o644`; use `0o600` for private files. */
+    readonly mode?: number;
+}
+/** Generate structured files from ordinary TypeScript values. Targets resolve relative to home. */
+declare const files: {
+    /**
+     * Generate TOML. Values must be representable in TOML (for example, no null).
+     * @example files.toml("~/.config/app/config.toml", { server: { port: 3000 } })
+     */
+    toml: (target: string, value: ConfigValue, options?: GeneratedFileOptions) => GeneratedFileResource;
+    /** Generate YAML with the standard overwrite/restore policy. */
+    yaml: (target: string, value: ConfigValue, options?: GeneratedFileOptions) => GeneratedFileResource;
+    /**
+     * Generate formatted JSON.
+     * @example files.json("~/.config/app/config.json", { enabled: true })
+     */
+    json: (target: string, value: ConfigValue, options?: GeneratedFileOptions) => GeneratedFileResource;
+    /** Generate JSONC from plain data or jsonc.concat/object commands with comments. */
+    jsonc: (target: string, value: ConfigValue | JsoncDocument, options?: GeneratedFileOptions) => GeneratedFileResource;
+};
+/**
+ * Declare a Linux systemd service. Defaults to user scope; system scope uses sudo.
+ * Use inside `linux(...)`. The `.service` suffix is added when omitted.
+ */
+declare function systemdService(name: string, options: Omit<SystemdServiceResource, "kind" | "name" | "scope"> & {
+    readonly scope?: SystemdServiceResource["scope"];
+}): SystemdServiceResource;
+/**
+ * Build a local source tree into an executable. Source changes trigger a rebuild.
+ * The build must write `{output}`; `{source}` and `{target}` are also available in arguments.
+ * @example customTool("hello", { source: "tools/hello", target: "~/.local/bin/hello", build: { command: "go", args: ["build", "-o", "{output}", "{source}"] } })
+ */
+declare function customTool(name: string, options: Omit<CustomToolResource, "kind" | "name" | "sourceHash">): CustomToolResource;
+/** Include resources when a TypeScript condition is true. For config fragments, use platform/machine helpers. */
+declare function when(condition: boolean, resources: ResourceInput): ResourceInput;
+/**
+ * Define an entry point or imported fragment. Arrays and factories compose; false, null and undefined are ignored.
+ * Later declarations with the same resource ID win.
+ * @example export default defineConfig({ resources: [tools.mise({ node: "lts" })] })
+ */
+declare function defineConfig(config: WorkstationConfig): WorkstationConfig;
+/** Define a configuration factory with typed access to machine, platform, home, and configDir. */
+declare function configure(factory: ConfigFactory): ConfigFactory;
+/**
+ * Include a configuration fragment only on macOS.
+ * @example defineConfig([common, darwin(macos)])
+ */
+declare function darwin(config: ConfigInput): ConfigFactory;
+/** Include a configuration fragment only on Linux. */
+declare function linux(config: ConfigInput): ConfigFactory;
+/**
+ * Include a fragment for one or more exact machine names. Defaults to the short hostname; `--machine` overrides it.
+ * @example machine(["studio", "macbook"], sharedMacConfig)
+ */
+declare function machine(names: string | readonly string[], config: ConfigInput): ConfigFactory;
+
+/** Supported shell rendering targets. */
+type Shell = "zsh" | "bash";
+/** A value expanded when the generated shell file runs, rather than during configuration loading. */
+type ShellExpression = {
+    readonly kind: "variable";
+    readonly name: string;
+} | {
+    readonly kind: "home";
+    readonly path: string;
+} | {
+    readonly kind: "concat";
+    readonly values: readonly ShellValue[];
+} | {
+    readonly kind: "capture";
+    readonly command: ShellCommand;
+};
+/** Plain strings are quoted literals. Use `shell.variable`, `shell.home`, or `shell.capture` for expansion. */
+type ShellValue = string | ShellExpression;
+/** A command plus individually quoted arguments; it is not executed while declaring configuration. */
+interface ShellCommand {
+    readonly command: string;
+    readonly args?: readonly ShellValue[];
+    readonly stderr?: "inherit" | "ignore";
+}
+/** A condition evaluated by the generated shell script. */
+type ShellCondition = {
+    readonly kind: "command-exists";
+    readonly command: string;
+} | {
+    readonly kind: "executable" | "file" | "directory";
+    readonly path: ShellValue;
+} | {
+    readonly kind: "empty" | "non-empty";
+    readonly value: ShellValue;
+} | {
+    readonly kind: "and";
+    readonly conditions: readonly ShellCondition[];
+} | {
+    readonly kind: "or";
+    readonly conditions: readonly ShellCondition[];
+} | {
+    readonly kind: "not";
+    readonly condition: ShellCondition;
+};
+/** A statement in the portable Zsh/Bash declaration language. */
+type ShellStatement = {
+    readonly kind: "export";
+    readonly name: string;
+    readonly value: ShellValue;
+} | {
+    readonly kind: "assign";
+    readonly name: string;
+    readonly value: ShellValue;
+} | {
+    readonly kind: "unset";
+    readonly names: readonly string[];
+} | {
+    readonly kind: "prepend-path";
+    readonly values: readonly ShellValue[];
+} | {
+    readonly kind: "alias";
+    readonly name: string;
+    readonly command: string;
+} | {
+    readonly kind: "eval";
+    readonly command: ShellCommand;
+} | {
+    readonly kind: "source";
+    readonly path: ShellValue;
+    readonly ifExists: boolean;
+} | {
+    readonly kind: "if";
+    readonly condition: ShellCondition;
+    readonly statements: readonly ShellStatement[];
+} | {
+    readonly kind: "zsh-setopt";
+    readonly options: readonly string[];
+} | {
+    readonly kind: "raw";
+    readonly code: string;
+};
+/** Generated startup-file options. Defaults to overwrite and mode `0o644`. */
+interface ShellFileOptions {
+    /** Defaults to overwrite; replaced originals are saved in local state for restoration. */
+    readonly ifExists?: IfExistsPolicy;
+    /** Unix permissions, for example `0o600`. */
+    readonly mode?: number;
+}
+/** Build shell statements without hand-written quoting. Helpers describe code; they do not execute commands. */
+declare const shell: {
+    /**
+     * Reference a shell variable at runtime.
+     * @example shell.export("VISUAL", shell.variable("EDITOR"))
+     */
+    variable(name: string): ShellExpression;
+    /**
+     * Expand a path under the shell's HOME at runtime.
+     * @example shell.home(".local/bin")
+     */
+    home(path?: string): ShellExpression;
+    /** Join literals and expressions into one shell value. */
+    concat(...values: readonly ShellValue[]): ShellExpression;
+    /** Use a command's stdout as a value via command substitution. */
+    capture(command: ShellCommand): ShellExpression;
+    /** Describe a command and its arguments. Use `capture` for its output or `eval` for initialization code. */
+    command(command: string, args?: readonly ShellValue[], options?: Pick<ShellCommand, "stderr">): ShellCommand;
+    /** Set and export an environment variable. */
+    export(name: string, value: ShellValue): ShellStatement;
+    /** Set a shell variable without exporting it. */
+    assign(name: string, value: ShellValue): ShellStatement;
+    /** Remove one or more shell variables. */
+    unset(...names: readonly string[]): ShellStatement;
+    /**
+     * Prepend paths while retaining the current PATH.
+     * @example shell.prependPath(shell.home(".local/bin"))
+     */
+    prependPath(...values: readonly ShellValue[]): ShellStatement;
+    /** Define an alias; its command text is interpreted when the alias runs. */
+    alias(name: string, command: string): ShellStatement;
+    /**
+     * Evaluate shell code printed by a command.
+     * @example shell.eval(shell.command("mise", ["activate", "zsh"]))
+     */
+    eval(command: ShellCommand): ShellStatement;
+    /** Source another shell file. With `ifExists: true`, source only when readable. */
+    source(path: ShellValue, options?: {
+        readonly ifExists?: boolean;
+    }): ShellStatement;
+    /** Generate a shell-time conditional containing one or more statements. */
+    when(condition: ShellCondition, statements: readonly ShellStatement[]): ShellStatement;
+    /** Insert literal shell code without validation or quoting. Prefer typed helpers for ordinary statements. */
+    raw(code: string): ShellStatement;
+    /** Construct conditions evaluated when the shell starts. */
+    condition: {
+        /** Test whether a command is available on PATH. */
+        commandExists(command: string): ShellCondition;
+        /** Test whether a path is executable. */
+        executable(path: ShellValue): ShellCondition;
+        /** Test whether a path is a regular file. */
+        file(path: ShellValue): ShellCondition;
+        /** Test whether a path is a directory. */
+        directory(path: ShellValue): ShellCondition;
+        /** Test whether a value is empty. */
+        empty(value: ShellValue): ShellCondition;
+        /** Test whether a value is non-empty. */
+        nonEmpty(value: ShellValue): ShellCondition;
+        /** Combine conditions with shell AND. */
+        and(...conditions: readonly ShellCondition[]): ShellCondition;
+        /** Combine conditions with shell OR. */
+        or(...conditions: readonly ShellCondition[]): ShellCondition;
+        /** Negate a condition. */
+        not(condition: ShellCondition): ShellCondition;
+    };
+};
+/** Declare independent Zsh startup files. Each defaults to overwrite with original-file restoration. */
+declare const zsh: {
+    /** Generate ~/.zshenv, read by every Zsh invocation. Keep this minimal. */
+    zshenv: (statements: readonly ShellStatement[], options?: ShellFileOptions) => GeneratedFileResource;
+    /** Generate ~/.zprofile for login-shell environment initialization. */
+    zprofile: (statements: readonly ShellStatement[], options?: ShellFileOptions) => GeneratedFileResource;
+    /** Generate ~/.zshrc for interactive aliases, prompts, and completion. */
+    zshrc: (statements: readonly ShellStatement[], options?: ShellFileOptions) => GeneratedFileResource;
+    /** Enable Zsh-only options using uppercase names. Cannot be rendered to Bash. */
+    setopt(...options: readonly string[]): ShellStatement;
+};
+/** Declare Bash startup files. Bash login shells read the first available profile file. */
+declare const bash: {
+    /** Generate ~/.bashrc for interactive non-login shells. */
+    bashrc: (statements: readonly ShellStatement[], options?: ShellFileOptions) => GeneratedFileResource;
+    /** Generate ~/.bash_profile for Bash login shells; source ~/.bashrc explicitly if desired. */
+    bashProfile: (statements: readonly ShellStatement[], options?: ShellFileOptions) => GeneratedFileResource;
+    /** Generate ~/.profile using Bash syntax; use only where Bash will read it. */
+    profile: (statements: readonly ShellStatement[], options?: ShellFileOptions) => GeneratedFileResource;
+};
+/** Render statements to shell text without writing a file or running a command. */
+declare function renderShell(statements: readonly ShellStatement[], target: Shell): string;
+
+/** Stable ownership key. File-like resources share their destination as an identity. */
+declare function resourceId(resource: ResolvedResource): string;
+/** SHA-256 of a declaration with object keys ordered consistently. Array order remains meaningful. */
+declare function fingerprint(resource: ResolvedResource): string;
+
+/** Resolve an explicit entry path, or find workstation.config.ts in the current directory. */
+declare function findConfig(explicit?: string): Promise<string>;
+/** Load an absolute TypeScript entry path, evaluate fragments, and resolve paths without applying resources. */
+declare function loadConfig(configPath: string, machineOverride?: string): Promise<ResolvedConfig>;
+
+/** Return the resolved config.toml path beside the private ownership state. */
+declare function manifestPath(config: ResolvedConfig): string;
+/** Write resolved declarations atomically as a private TOML manifest. */
+declare function writeManifest(path: string, config: ResolvedConfig): Promise<void>;
+/** Read and validate a resolved manifest; reject unsupported schema versions. */
+declare function readManifest(path: string): Promise<ResolvedConfig>;
+
+interface LockedConfigResult {
+    readonly config: ResolvedConfig;
+    readonly path: string;
+    readonly changed: boolean;
+}
+/** Return the workstation.lock path beside the TypeScript entry point. */
+declare function lockPath(configPath: string): string;
+/** Resolve package pins and update the current machine's lock target; does not install resources. */
+declare function lockConfig(configPath: string, config: ResolvedConfig, runner: Runner): Promise<LockedConfigResult>;
+
+/** Run child processes directly, inheriting stdin and capturing stdout/stderr. No implicit shell is used. */
+declare class ProcessRunner implements Runner {
+    /** Execute a command directly and return captured output and its exit code; spawn failures reject. */
+    run(command: string, args: readonly string[], options?: RunOptions): Promise<CommandResult>;
+}
+
+export { type Action, type ActionType, type BrewCaskUpgradeOptions, type CommandResult, type CommandSpec, type ConfigDefinition, type ConfigFactory, type ConfigInput, type ConfigValue, type Context, type CustomToolResource, type GeneratedFileOptions, type GeneratedFileResource, type IfExistsPolicy, type JsoncCommand, JsoncDocument, type JsoncLine, type LaunchAgentResource, type LockedConfigResult, type OriginalFile, type PackageManager, type PackageResource, type Platform, ProcessRunner, type ResolvedConfig, type ResolvedPackageResource, type ResolvedResource, type Resource, type ResourceInput, type RunOptions, type Runner, type Shell, type ShellCommand, type ShellCondition, type ShellExpression, type ShellFileOptions, type ShellStatement, type ShellValue, type StateEntry, type StructuredFormat, type SymlinkResource, type SystemdScope, type SystemdServiceResource, type TaskDefinition, type WorkstationConfig, type WorkstationState, bash, configure, customTool, darwin, defineConfig, files, findConfig, fingerprint, jsonc, launchAgent, linux, loadConfig, lockConfig, lockPath, machine, manifestPath, readManifest, renderShell, resourceId, runTask, shell, symlink, systemdService, task, tools, when, writeManifest, zsh };