@denvig/sdk 0.7.0-alpha.4

package/dist/teardown-BuHyVdhH.d.ts

@@ -0,0 +1,764 @@
+import { z } from "zod";
+
+//#region src/lib/actions/types.d.ts
+type Actions = Record<string, string[]>;
+//#endregion
+//#region src/schemas/config.d.ts
+/**
+ * Global configuration for the system.
+ *
+ * This is located in ~/.denvig/config.yml but can be overridden by ENV.DENVIG_GLOBAL_CONFIG_PATH
+ */
+declare const GlobalConfigSchema: z.ZodObject<{
+  projectPaths: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  quickActions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+  services: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    command: z.ZodString;
+    http: z.ZodOptional<z.ZodObject<{
+      port: z.ZodOptional<z.ZodNumber>;
+      domain: z.ZodOptional<z.ZodString>;
+      cnames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      secure: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    envFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    keepAlive: z.ZodOptional<z.ZodBoolean>;
+    startOnBoot: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>>;
+  experimental: z.ZodOptional<z.ZodObject<{
+    gateway: z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodBoolean;
+      handler: z.ZodDefault<z.ZodEnum<{
+        nginx: "nginx";
+      }>>;
+      configsPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type GlobalConfigSchema = z.infer<typeof GlobalConfigSchema>;
+/**
+ * The per project configuration.
+ * This is usually loaded from ~/.denvig.yml or ~/.denvig/config.yml
+ *
+ * @example
+ * name: My Project
+ * actions:
+ *   build:
+ *     command: pnpm build
+ *   clean:
+ *     command: rf -rf dist
+ */
+declare const ProjectConfigSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    command: z.ZodString;
+  }, z.core.$strip>>>;
+  quickActions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  services: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    command: z.ZodString;
+    http: z.ZodOptional<z.ZodObject<{
+      port: z.ZodOptional<z.ZodNumber>;
+      domain: z.ZodOptional<z.ZodString>;
+      cnames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      secure: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    envFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    keepAlive: z.ZodOptional<z.ZodBoolean>;
+    startOnBoot: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ProjectConfigSchema = z.infer<typeof ProjectConfigSchema>;
+//#endregion
+//#region src/lib/config.d.ts
+type ConfigWithSourcePaths<C> = C & {
+  $sources: string[];
+};
+/**
+ * Load global config with the following precedence (highest to lowest):
+ * 1. Environment variables (DENVIG_PROJECT_PATHS, DENVIG_QUICK_ACTIONS)
+ * 2. ~/.denvig/config.yml
+ * 3. Default values
+ */
+declare const getGlobalConfig: () => Promise<ConfigWithSourcePaths<GlobalConfigSchema>>;
+//#endregion
+//#region src/lib/services/launchctl.d.ts
+/**
+ * Parsed output from launchctl print command.
+ */
+type LaunchctlPrintOutput = {
+  pid?: number;
+  status: string;
+  label: string;
+  state: string;
+  lastExitCode?: number;
+};
+/**
+ * Item from launchctl list command.
+ */
+type LaunchctlListItem = {
+  pid: number | '-';
+  status: number;
+  label: string;
+};
+/**
+ * Get the user domain for launchctl commands.
+ *
+ * @returns Domain string in format "gui/USER_ID"
+ */
+declare function getUserDomain(): string;
+/**
+ * Bootstrap a service (load and start).
+ *
+ * @param plistPath - Path to the plist file
+ * @returns Result with success status and output
+ */
+declare function bootstrap(plistPath: string): Promise<{
+  success: boolean;
+  output: string;
+}>;
+/**
+ * Bootout a service (unload and stop).
+ *
+ * @param label - Service label
+ * @returns Result with success status and output
+ */
+declare function bootout(label: string): Promise<{
+  success: boolean;
+  output: string;
+}>;
+/**
+ * Start a service (must be already bootstrapped).
+ *
+ * @param label - Service label
+ * @returns Result with success status and output
+ */
+declare function start(label: string): Promise<{
+  success: boolean;
+  output: string;
+}>;
+/**
+ * Stop a service (keeps it bootstrapped).
+ *
+ * @param label - Service label
+ * @returns Result with success status and output
+ */
+declare function stop(label: string): Promise<{
+  success: boolean;
+  output: string;
+}>;
+/**
+ * Enable a service so it can be started by launchd.
+ *
+ * @param label - Service label
+ * @returns Result with success status and output
+ */
+declare function enable(label: string): Promise<{
+  success: boolean;
+  output: string;
+}>;
+/**
+ * Disable a service so launchd will not start it on login.
+ *
+ * @param label - Service label
+ * @returns Result with success status and output
+ */
+declare function disable(label: string): Promise<{
+  success: boolean;
+  output: string;
+}>;
+/**
+ * Get service information.
+ *
+ * @param label - Service label
+ * @returns Parsed service info or null if not found
+ */
+declare function print(label: string): Promise<LaunchctlPrintOutput | null>;
+/**
+ * List all services matching a pattern.
+ *
+ * @param pattern - Optional pattern to filter services
+ * @returns Array of service items
+ */
+declare function list(pattern?: string): Promise<LaunchctlListItem[]>;
+declare const _default: {
+  bootstrap: typeof bootstrap;
+  bootout: typeof bootout;
+  enable: typeof enable;
+  disable: typeof disable;
+  start: typeof start;
+  stop: typeof stop;
+  print: typeof print;
+  list: typeof list;
+  getUserDomain: typeof getUserDomain;
+};
+//#endregion
+//#region src/lib/project/git.d.ts
+/** Run `git pull` in the given directory. */
+declare const gitPull: (cwd: string) => Promise<boolean>;
+/** Check if a git working tree has uncommitted changes. */
+declare const isWorkingTreeDirty: (cwd: string) => Promise<boolean>;
+type ProjectWorktree = {
+  /** Absolute path of the detached worktree's checkout. */path: string; /** Branch checked out in the detached worktree. */
+  branch: string;
+};
+//#endregion
+//#region src/lib/project.d.ts
+/**
+ * A project is the primary git checkout plus every detached worktree that
+ * descends from it. Its identity (`id`, `slug`, `refs`, `path`, `name`) is the
+ * primary checkout's.
+ *
+ * Everything path-sensitive (config, dependencies, actions, services) lives on
+ * a {@link Worktree}. Use `activeWorktree` for the checkout a command is acting
+ * on, `primaryWorktree` for the project root, or `worktree(branch)` to select a
+ * specific one.
+ */
+declare class DenvigProject {
+  /** The primary checkout (`main`). Defines the project's identity. */
+  readonly primaryWorktree: Worktree;
+  /** Every checkout: the primary plus all detached worktrees. */
+  readonly worktrees: Worktree[];
+  /** The checkout this project instance is acting on. */
+  activeWorktree: Worktree;
+  private constructor();
+  /**
+   * Retrieve a project from any path inside it (the primary checkout or a
+   * detached worktree). The project's identity is rooted at the primary, and
+   * the checkout matching `projectPath` becomes the active worktree.
+   */
+  static retrieve(projectPath: string): Promise<DenvigProject>;
+  /** Select a worktree by branch. `main` resolves to the primary checkout. */
+  worktree(branch: string): Worktree | null;
+  /** Project identity, rooted at the primary checkout. */
+  get id(): string;
+  get slug(): string;
+  /**
+   * All identifiers for the project. See `projectRefs()` for the format
+   * of each ref (`id:`, `local:`, `github:`, `git:`).
+   */
+  get refs(): string[];
+  get name(): string;
+  /** Absolute path of the primary checkout. */
+  get path(): string;
+}
+//#endregion
+//#region src/lib/projectInfo.d.ts
+type ServiceStatus$1 = 'running' | 'stopped' | 'none';
+type ProjectInfo = {
+  id: string;
+  slug: string;
+  name: string;
+  path: string;
+  refs: string[];
+  worktrees: ProjectWorktree[];
+  config: ProjectConfigSchema | null;
+  serviceStatus: ServiceStatus$1;
+};
+type GetProjectInfoOptions = {
+  /** Pre-fetched launchctl list to avoid repeated shell calls */launchctlList?: LaunchctlListItem[]; /** Include service status in the response (requires launchctl calls) */
+  includeServiceStatus?: boolean;
+};
+//#endregion
+//#region src/types/responses.d.ts
+/**
+ * Service information for display.
+ */
+type ServiceInfo = {
+  name: string;
+  cwd: string;
+  command: string;
+  http?: {
+    port?: number;
+    domain?: string;
+    secure?: boolean;
+  };
+  startOnBoot?: boolean;
+};
+/**
+ * Result of a service operation.
+ */
+type ServiceResult = {
+  name: string;
+  success: boolean;
+  message: string;
+};
+/**
+ * Status of a running service.
+ */
+type ServiceStatus = {
+  name: string;
+  running: boolean;
+  pid?: number;
+  uptime?: string;
+  command: string;
+  cwd: string;
+  logs?: string[];
+  logPath: string;
+  lastExitCode?: number;
+};
+/**
+ * Project data included in service responses.
+ */
+type ServiceProjectData = {
+  id: string;
+  slug: string;
+  name: string;
+  path: string;
+};
+/**
+ * Unified service response for all service commands.
+ * Used by list, status, start, stop, and restart commands.
+ */
+type ServiceResponse = {
+  name: string;
+  project: ServiceProjectData;
+  status: 'running' | 'error' | 'stopped';
+  pid: number | null;
+  /**
+   * Canonical URL for the service. The domain URL when this service owns
+   * the gateway route, otherwise a direct `http://localhost:<port>` URL.
+   */
+  url: string | null;
+  /**
+   * Direct `http://localhost:<port>` URL when an effective port is known.
+   * Useful when the gateway route is held by another service (e.g. a
+   * sibling worktree) and `url` falls back to the localhost form already.
+   */
+  localUrl: string | null; /** Effective port the service is configured to listen on. */
+  port: number | null; /** Port declared in the service config, if any. */
+  configPort: number | null;
+  command: string;
+  cwd: string;
+  logPath: string;
+  envFiles: string[];
+  lastExitCode: number | null;
+  logs?: string[];
+};
+/**
+ * Version information for a dependency.
+ */
+type DependencyVersion = {
+  resolved: string;
+  specifier: string;
+  source: string;
+  wanted?: string;
+  latest?: string;
+};
+/**
+ * A project dependency from deps:list command.
+ */
+type Dependency = {
+  id: string;
+  name: string;
+  versions: DependencyVersion[];
+  ecosystem: string;
+};
+/**
+ * An outdated dependency from deps:outdated command.
+ */
+type OutdatedDependency = Dependency & {
+  wanted: string;
+  latest: string;
+  specifier: string;
+  isDevDependency: boolean;
+  currentDate?: string;
+  wantedDate?: string;
+  latestDate?: string;
+};
+//#endregion
+//#region src/lib/plugin.d.ts
+/**
+ * Options for outdatedDependencies method
+ */
+type OutdatedDependenciesOptions = {
+  /** Use cache for registry requests (default: true) */cache?: boolean;
+  /**
+   * How many levels of the dependency tree to include.
+   * 0 (default) = direct dependencies only.
+   * N > 0 = direct deps plus transitive dependencies up to depth N.
+   */
+  depth?: number;
+};
+/**
+ * Options for deduplicateDependencies method
+ */
+type DeduplicateDependenciesOptions = {
+  /** Only analyze without applying changes (default: false) */dryRun?: boolean;
+};
+/**
+ * Details of a package that can be deduplicated.
+ */
+type DeduplicateDetail = {
+  name: string;
+  versions: string[];
+  optimisedVersions: string[];
+};
+/**
+ * Result of a deduplication analysis/operation.
+ */
+type DeduplicateResult = {
+  ecosystem: string;
+  totalDependencies: number;
+  optimisedDependencies: number;
+  removals: Record<string, string[]>;
+  details: DeduplicateDetail[];
+  applied: boolean;
+};
+//#endregion
+//#region src/lib/project/worktree.d.ts
+/**
+ * A single git checkout belonging to a project — either the primary checkout
+ * or a detached worktree. Everything path-sensitive (config, dependencies,
+ * actions, refs) lives here, since these all differ between checkouts.
+ *
+ * A worktree's `refs`, `id` and `slug` are derived from its own path, so they
+ * match the values the legacy `DenvigProject` produced for that checkout. This
+ * keeps service state keys (which are derived from these) stable across the
+ * project-owns-worktrees refactor.
+ */
+declare class Worktree {
+  /** Absolute path of this checkout. */
+  readonly path: string;
+  /** Branch checked out here. The primary checkout always reports `main`. */
+  readonly branch: string;
+  /** True when this is the project's primary checkout. */
+  readonly isPrimary: boolean;
+  /** All identifiers for this checkout. See `projectRefs()` for the format. */
+  readonly refs: string[];
+  readonly slug: string;
+  readonly id: string;
+  config: ConfigWithSourcePaths<ProjectConfigSchema>;
+  private _rootFilesCache;
+  private constructor();
+  /** Retrieve a worktree by looking up its config and root files. */
+  static retrieve(path: string, branch: string, isPrimary: boolean): Promise<Worktree>;
+  get name(): string;
+  /** List of files in the root of this checkout. */
+  get rootFiles(): string[];
+  get packageManagers(): string[];
+  get primaryPackageManager(): string | null;
+  dependencies(): Promise<Dependency[]>;
+  outdatedDependencies(options?: OutdatedDependenciesOptions): Promise<OutdatedDependency[]>;
+  deduplicateDependencies(options?: DeduplicateDependenciesOptions): Promise<DeduplicateResult[]>;
+  /** All actions that can be run for this checkout. */
+  get actions(): Promise<Actions>;
+  /** All services defined in this checkout's configuration. */
+  get services(): Record<string, {
+    command: string;
+    cwd?: string | undefined;
+    http?: {
+      port?: number | undefined;
+      domain?: string | undefined;
+      cnames?: string[] | undefined;
+      secure?: boolean | undefined;
+    } | undefined;
+    envFiles?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    keepAlive?: boolean | undefined;
+    startOnBoot?: boolean | undefined;
+  }>;
+  /** Find all files recursively with a given name in this checkout. */
+  findFilesByName(fileName: string): Promise<string[]>;
+}
+//#endregion
+//#region src/lib/formatters/tree-node.d.ts
+/**
+ * A node in a tree structure for rendering. The shape is produced by logic in
+ * the SDK (e.g. dependency chains) and consumed by the CLI's tree renderer.
+ */
+type TreeNode = {
+  name: string;
+  version: string;
+  children: TreeNode[]; /** Optional ANSI color applied to the entire `name version` body. */
+  color?: string; /** Optional preformatted suffix appended after the version. */
+  suffix?: string;
+};
+//#endregion
+//#region src/lib/deps/tree.d.ts
+/**
+ * A dependency entry with tree metadata for rendering.
+ */
+type TreeDependencyEntry = {
+  name: string;
+  version: string;
+  ecosystem: string;
+  isDevDependency: boolean;
+  depth: number;
+  isLast: boolean;
+  hasChildren: boolean;
+  parentPath: boolean[];
+  dependencyType?: string;
+};
+/**
+ * Check if a source is from devDependencies section.
+ */
+declare const isDevDependenciesSource: (source: string) => boolean;
+/**
+ * Build a reverse dependency chain from a target dependency back to a direct dependency.
+ * Returns the chain as a tree structure starting from the root, or null if chain cannot be built.
+ */
+declare const buildReverseChain: (targetName: string, targetVersion: string, source: string, depsMap: Map<string, Dependency>) => TreeNode | null;
+//#endregion
+//#region src/lib/services/manager.d.ts
+type ServiceConfig = NonNullable<ProjectConfigSchema['services']>[string];
+/**
+ * Minimal project shape required by ServiceManager.
+ * DenvigProject structurally satisfies this type.
+ */
+type ServiceManagerProject = {
+  id: string;
+  slug: string;
+  name: string;
+  path: string;
+  config: {
+    services?: ProjectConfigSchema['services'];
+  };
+};
+/**
+ * Manager for project services.
+ */
+declare class ServiceManager {
+  private project;
+  constructor(project: ServiceManagerProject);
+  /**
+   * List all services defined in the project configuration.
+   */
+  listServices(): Promise<ServiceInfo[]>;
+  /**
+   * Build environment variables for a service.
+   * This loads env files and merges with explicit env config.
+   * All env files are optional - missing files are silently skipped.
+   *
+   * @param options.port - Effective port for the service. When provided,
+   *   overrides any port defined in config and is exported as `PORT` in
+   *   the service environment.
+   */
+  buildServiceEnvironment(name: string, options?: {
+    port?: number;
+  }): Promise<{
+    success: true;
+    env: Record<string, string>;
+  } | {
+    success: false;
+    message: string;
+  }>;
+  /**
+   * Decide which port to run a service on.
+   *
+   * Resolution order:
+   * 1. If `forceRandom`, always allocate a fresh random port (preferring the
+   *    previously-allocated one when free).
+   * 2. If state already records a port for this service, reuse it. State is
+   *    authoritative once allocated so restarts stay on the same port and
+   *    don't re-prompt about the config port being busy. Run
+   *    `services teardown` to reset.
+   * 3. Otherwise try the config port — falling back to a random port and
+   *    flagging `conflict: true` when it's already in use.
+   * 4. Otherwise (no config port, no state) allocate a random port.
+   */
+  resolveServicePort(name: string, options?: {
+    forceRandom?: boolean;
+  }): Promise<{
+    success: true;
+    port: number | undefined;
+    source: 'config' | 'allocated' | 'state' | 'none';
+    conflict: boolean;
+    configPort?: number;
+  } | {
+    success: false;
+    message: string;
+  }>;
+  /**
+   * Start a specific service.
+   *
+   * @param options.port - Pre-resolved port to use for this service. When
+   *   omitted, the manager resolves the port itself, auto-allocating a
+   *   random port if the config port is busy.
+   * @param options.claimDomain - When the service's configured domain is
+   *   already claimed by a different project, this flag controls whether
+   *   this start should replace the route as an override (`true`) or
+   *   leave the existing route alone (`false`). When undefined and the
+   *   domain has no existing owner, the route is registered as the
+   *   natural owner (`defaultService: true`).
+   * @param options.reviveIfNotRunning - When the service is already
+   *   bootstrapped with an unchanged plist but isn't currently running,
+   *   bootout and bootstrap again to kick it (`true`, the default — what an
+   *   explicit `start` wants). The reconciler passes `false`: a bootstrapped
+   *   service's liveness is launchd's job (`KeepAlive` respawns it, one-shot
+   *   services are meant to stay exited), so re-bootstrapping an unchanged
+   *   plist is needless churn that fights launchd.
+   */
+  startService(name: string, options?: {
+    port?: number;
+    portResolved?: boolean;
+    claimDomain?: boolean;
+    reviveIfNotRunning?: boolean;
+  }): Promise<ServiceResult>;
+  /**
+   * Stop a specific service.
+   */
+  stopService(name: string): Promise<ServiceResult>;
+  /**
+   * Restart a specific service.
+   */
+  restartService(name: string, options?: {
+    port?: number;
+    portResolved?: boolean;
+    claimDomain?: boolean;
+  }): Promise<ServiceResult>;
+  /**
+   * Get the status of a specific service.
+   */
+  getServiceStatus(name: string): Promise<ServiceStatus | null>;
+  /**
+   * Start all services.
+   */
+  startAll(): Promise<ServiceResult[]>;
+  /**
+   * Stop all running services.
+   */
+  stopAll(): Promise<ServiceResult[]>;
+  /**
+   * Restart all services (only those currently bootstrapped).
+   */
+  restartAll(): Promise<ServiceResult[]>;
+  /**
+   * Teardown all services for this project.
+   * Stops all services, removes them from launchctl, and deletes plist files.
+   * @param options.removeLogs - Also remove log files (default: false)
+   */
+  teardownAll(options?: {
+    removeLogs?: boolean;
+  }): Promise<ServiceResult[]>;
+  /**
+   * Check if a service is bootstrapped (loaded in launchctl).
+   */
+  isServiceBootstrapped(name: string): Promise<boolean>;
+  /**
+   * Normalize a string for use in launchctl labels and filenames.
+   * Replaces special characters with safe alternatives.
+   */
+  private normalizeForLabel;
+  /**
+   * Get the service label for launchctl.
+   * Format: denvig.[projectId].[serviceName]
+   */
+  getServiceLabel(name: string): string;
+  /**
+   * Get the denvig directory path.
+   */
+  getDenvigHomeDir(): string;
+  /**
+   * Get the plist file path.
+   */
+  getPlistPath(name: string): string;
+  /**
+   * Get the service-specific directory.
+   * Format: ~/.denvig/services/[projectId].[serviceName]/
+   */
+  getServiceDir(name: string): string;
+  /**
+   * Get the service-specific log directory.
+   * Format: ~/.denvig/services/[projectId].[serviceName]/logs/
+   */
+  getServiceLogDir(name: string): string;
+  /**
+   * Get the path to the service wrapper script.
+   * Includes the project slug in the filename for github projects so Login Items
+   * shows a meaningful name (e.g. "denvig-marcqualie-myapp-api").
+   */
+  getServiceScriptPath(name: string): string;
+  /**
+   * Get the stable log path used by the plist StandardOutPath.
+   * This is a symlink that always points to the current timestamped log file.
+   * Format: ~/.denvig/services/[serviceId]/logs/latest.log
+   */
+  getStableLogPath(name: string): string;
+  /**
+   * Get the log file path (symlink to latest log for this host).
+   * Format: ~/.denvig/services/[serviceId]/logs/latest.[hostname].log
+   */
+  getLogPath(name: string, _type?: 'stdout' | 'stderr'): string;
+  /**
+   * Create a new timestamped log file and update the latest symlink.
+   * Returns the absolute path to the new log file.
+   */
+  createLogFile(name: string): Promise<string>;
+  /**
+   * Ensure denvig directories exist.
+   */
+  ensureDenvigDirectories(): Promise<void>;
+  /**
+   * Get recent log lines from a service.
+   */
+  getRecentLogs(name: string, lines: number): Promise<string[]>;
+  /**
+   * Resolve the absolute working directory for a service.
+   */
+  private resolveServiceCwd;
+  /**
+   * Get the configuration for a specific service.
+   */
+  getServiceConfig(name: string): ServiceConfig | undefined;
+  /**
+   * Rebuild all gateway nginx configs across all projects.
+   * Removes stale configs and regenerates from current service definitions.
+   */
+  reconfigureGateway(): Promise<void>;
+  /**
+   * Get the canonical URL where a service can be accessed. Returns the
+   * domain URL only when this service currently owns the gateway route for
+   * its configured domain; otherwise (or when no domain is configured)
+   * falls back to a direct `http://localhost:<port>` URL.
+   */
+  getServiceUrl(name: string): Promise<string | null>;
+  /**
+   * Get the direct localhost URL for a service (`http://localhost:<port>`),
+   * or null if there's no effective port yet.
+   */
+  getServiceLocalUrl(name: string): Promise<string | null>;
+  /**
+   * Get the effective runtime port for a service, considering state-tracked
+   * allocations first and falling back to the config port.
+   */
+  getEffectivePort(name: string): Promise<number | undefined>;
+  /**
+   * Check if a plist file exists for a service.
+   */
+  plistExists(name: string): Promise<boolean>;
+  /**
+   * Get a unified service response for a service.
+   * Returns null if the service is not found in configuration.
+   * @param name - Service name
+   * @param options.includeLogs - Whether to include recent logs (default: false)
+   * @param options.logLines - Number of log lines to include (default: 20)
+   * @param options.launchctlList - Pre-fetched launchctl list for batch operations (avoids N shell calls)
+   */
+  getServiceResponse(name: string, options?: {
+    includeLogs?: boolean;
+    logLines?: number;
+    launchctlList?: LaunchctlListItem[];
+  }): Promise<ServiceResponse | null>;
+}
+//#endregion
+//#region src/lib/teardown.d.ts
+type TeardownResult = {
+  success: boolean;
+  services: ServiceResult[];
+  logsRemoved: boolean;
+};
+type ProjectTeardownResult = TeardownResult & {
+  project: string;
+};
+type TeardownOptions = {
+  removeLogs?: boolean;
+};
+/**
+ * Teardown all denvig services globally (across all projects).
+ */
+declare function teardownGlobal(options?: TeardownOptions): Promise<TeardownResult>;
+//#endregion
+export { _default as C, ProjectConfigSchema as D, GlobalConfigSchema as E, LaunchctlListItem as S, getGlobalConfig as T, ProjectInfo as _, TreeDependencyEntry as a, gitPull as b, TreeNode as c, DeduplicateResult as d, OutdatedDependenciesOptions as f, GetProjectInfoOptions as g, ServiceResponse as h, ServiceManagerProject as i, Worktree as l, OutdatedDependency as m, teardownGlobal as n, buildReverseChain as o, Dependency as p, ServiceManager as r, isDevDependenciesSource as s, ProjectTeardownResult as t, DeduplicateDependenciesOptions as u, ServiceStatus$1 as v, ConfigWithSourcePaths as w, isWorkingTreeDirty as x, DenvigProject as y };