@slopus/happy-terminal 0.3.0-beta.13

package/dist/app/truncateUtf8BytesForDisplay.d.ts

@@ -0,0 +1 @@
+export declare function truncateUtf8BytesForDisplay(value: string, maximumBytes: number): string;

package/dist/app/upsertSubagentSummary.d.ts

@@ -0,0 +1,2 @@
+import type { SubagentSummary } from "../protocol/index.js";
+export declare function upsertSubagentSummary(subagents: readonly SubagentSummary[], next: SubagentSummary): readonly SubagentSummary[];

package/dist/app/workflowDisplay.d.ts

@@ -0,0 +1,2 @@
+export declare function humanizeWorkflowName(name: string): string;
+export declare function serializeWorkflowValue(value: unknown): string;

package/dist/client/HappyAgentEventHub.d.ts

@@ -0,0 +1,25 @@
+import type { EventCursor, HappyAgentClient, HappyAgentEvent } from "@slopus/happy-agent-client";
+/**
+ * Happy Terminal's one global daemon event subscription.
+ *
+ * The hub keeps a small replay window so a mutation can answer with a cursor
+ * before its caller begins waiting. Conversation settlement, title updates,
+ * questions, and other live UI all fan out from this one ordered source.
+ */
+export declare class HappyAgentEventHub {
+    #private;
+    constructor(client: HappyAgentClient, after: EventCursor);
+    start(): void;
+    close(): Promise<void>;
+    /**
+     * Replays everything after `after`, then follows live until `onEvent`
+     * returns true or the signal is aborted.
+     */
+    follow(options: {
+        after: EventCursor;
+        /** Refreshes authoritative state when the daemon can no longer replay `after`. */
+        onGap: (cursor: EventCursor) => void | Promise<void>;
+        onEvent: (event: HappyAgentEvent) => boolean | Promise<boolean>;
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

package/dist/client/RemoteAgent.d.ts

@@ -0,0 +1,74 @@
+import type { Context } from "@steve.kite/stdlib";
+import type { Agent as ApiAgent, AgentBootstrapResponse, DaemonConfig, HappyAgentClient, HappyAgentEvent, MessageHistoryResponse } from "@slopus/happy-agent-client";
+import type { AgentCompactionResult, AgentLoopEvent, AgentSnapshot, ContentBlock, Message, Model, PermissionMode, ServiceTier } from "../protocol/index.js";
+import type { AgentRunOptions, AgentRunResult, CodingAssistantAgentBackend, CodingAssistantClientProvider, CodingAssistantModelChoice, SteeringRunOptions } from "../app/CodingAssistantAgentBackend.js";
+import type { AbortRunOptions, AbortRunResponse, GetSessionUsageResponse, ReadBackgroundProcessResponse, RunShellCommandResponse, SessionProviderQuota, SteerMessageResponse, StopBackgroundProcessResponse } from "../protocol/index.js";
+import type { HappyAgentEventHub } from "./HappyAgentEventHub.js";
+export interface RemoteAgentOptions {
+    agent: ApiAgent;
+    bootstrap: AgentBootstrapResponse;
+    client: HappyAgentClient;
+    config: DaemonConfig;
+    events: HappyAgentEventHub;
+    history: MessageHistoryResponse;
+}
+/**
+ * The TUI's agent backend over the public Happy Agent API.
+ *
+ * This class projects public message blocks into Happy Terminal's renderer vocabulary, but
+ * it never reconstructs or calls the removed session protocol. Runs, messages,
+ * steering, compaction, drafts, questions, and processes all go through the
+ * durable `HappyAgentClient` instance supplied by the daemon connection.
+ */
+export declare class RemoteAgent implements CodingAssistantAgentBackend {
+    #private;
+    readonly id: string;
+    constructor(options: RemoteAgentOptions);
+    get canChangeModel(): boolean;
+    get confirmedServiceTier(): ServiceTier | undefined;
+    get provider(): CodingAssistantClientProvider;
+    get model(): Model;
+    get modelChoices(): readonly CodingAssistantModelChoice[];
+    get permissionMode(): PermissionMode;
+    get draft(): string;
+    get draftUpdatedAt(): number | undefined;
+    setDraft(draft: string, options?: {
+        origin?: string;
+        updatedAt?: number;
+    }): Promise<void>;
+    abort(options?: AbortRunOptions): Promise<AbortRunResponse>;
+    stopBackgroundProcesses(): Promise<number>;
+    readBackgroundProcess(_sessionId: number, _options?: {
+        waitMs?: number;
+    }): Promise<ReadBackgroundProcessResponse | undefined>;
+    stopBackgroundProcess(_sessionId: number): Promise<StopBackgroundProcessResponse>;
+    /**
+     * The current provider's account quota, probed at most once per provider. Happy Terminal signs in
+     * through the system coding assistants, so the terminal asks the vendor with this machine's
+     * own credentials rather than adding a daemon surface for it.
+     */
+    providerQuotas(): Promise<readonly SessionProviderQuota[]>;
+    getUsage(): Promise<GetSessionUsageResponse>;
+    compact(_ctx: Context, _signal?: AbortSignal, _onEvent?: AgentRunOptions["onEvent"]): Promise<AgentCompactionResult>;
+    reset(): Promise<void>;
+    runShellCommand(_command: string, _options: {
+        commandId: string;
+    }): Promise<RunShellCommandResponse>;
+    steer(content: string | readonly ContentBlock[], options?: SteeringRunOptions): Promise<void | SteerMessageResponse>;
+    send(_ctx: Context, content: string | readonly ContentBlock[], options?: AgentRunOptions): Promise<AgentRunResult>;
+    setEffort(effort: string | undefined): void;
+    setModel(modelId: string, effort: string | undefined, providerId?: string): void;
+    setServiceTier(serviceTier: ServiceTier | undefined): void;
+    setPermissionMode(permissionMode: PermissionMode): Promise<void>;
+    snapshot(): AgentSnapshot;
+    /** Reloads the authoritative agent and transcript after an event-stream gap. */
+    resync(): Promise<AgentSnapshot>;
+    /** Applies one global API event and returns a renderable message when it carried one. */
+    applyEvent(event: HappyAgentEvent): Message | undefined;
+    /**
+     * Projects streaming and reset API events into Happy Terminal's live inference vocabulary. A send that
+     * carries its own onEvent callback receives loop events there instead, so this global path
+     * stays silent for it rather than delivering every event twice.
+     */
+    applyLoopEvent(event: HappyAgentEvent): AgentLoopEvent | undefined;
+}

package/dist/client/RemoteAgentRunError.d.ts

@@ -0,0 +1,4 @@
+export declare class RemoteAgentRunError extends Error {
+    readonly debugDirectory: string | undefined;
+    constructor(message: string, debugDirectory?: string);
+}

package/dist/client/RemoteTerminalAttachment.d.ts

@@ -0,0 +1,19 @@
+import type { GhosttyTerminal } from "@slopus/ghostty-wasm/node";
+import { type RemoteTerminalProtocolClient, type RemoteTerminalReconnectState, type RemoteTerminalScrollbackPage } from "@slopus/ghostty-web";
+import type { RemoteTerminalClientReplica } from "./RemoteTerminalClientReplica.js";
+export declare class RemoteTerminalAttachment {
+    #private;
+    readonly clientId: string;
+    readonly exited: Promise<number | null>;
+    readonly protocol: RemoteTerminalProtocolClient;
+    readonly replica: RemoteTerminalClientReplica;
+    readonly terminal: GhosttyTerminal;
+    constructor(clientId: string, replica: RemoteTerminalClientReplica, createProtocol: (onExit: (exitCode: number | null) => void) => RemoteTerminalProtocolClient);
+    close(): void;
+    reconnectState(): RemoteTerminalReconnectState;
+    requestScrollback(start: number, count: number, basis?: {
+        historyEpoch: string;
+        historyRevision: number;
+    }): Promise<RemoteTerminalScrollbackPage>;
+    writeInput(data: Uint8Array | string): number;
+}

package/dist/client/RemoteTerminalClientReplica.d.ts

@@ -0,0 +1,14 @@
+import { type GhosttyTerminal } from "@slopus/ghostty-wasm/node";
+import { type RemoteTerminalGridState, type RemoteTerminalReplica } from "@slopus/ghostty-web";
+import type { RemoteTerminalColorScheme } from "../terminal/index.js";
+export declare class RemoteTerminalClientReplica implements RemoteTerminalReplica {
+    #private;
+    grid: RemoteTerminalGridState | undefined;
+    readonly terminal: GhosttyTerminal;
+    private constructor();
+    static create(colorScheme: RemoteTerminalColorScheme): Promise<RemoteTerminalClientReplica>;
+    applyGrid(state: RemoteTerminalGridState): void;
+    applyVt(data: Uint8Array): void | Promise<void>;
+    close(): void;
+    resize(cols: number, rows: number): void | Promise<void>;
+}

package/dist/client/ensureLocalProtocolServer.d.ts

@@ -0,0 +1,10 @@
+/** Retained as a type-only compatibility surface for older terminal integrations. */
+export interface DaemonRestartRequest {
+    currentIdentity: {
+        version: string;
+    };
+    runningIdentity: {
+        version: string;
+    };
+}
+export { ensureLocalProtocolServer, readTokenIfPresent, runDaemonInProcess, type EnsureLocalProtocolServerOptions, type LocalProtocolServerConnection, } from "../daemon/index.js";

package/dist/client/fetchProviderQuotas.d.ts

@@ -0,0 +1,10 @@
+import type { SessionProviderQuota } from "../protocol/index.js";
+/**
+ * Probes the current provider's account quota with this machine's own credentials.
+ *
+ * Happy Terminal signs in through the system coding assistants, so the quota that matters is the one their
+ * credentials see; the terminal asks the vendor directly rather than adding a daemon surface for
+ * it. Quota is a courtesy: a provider without a quota window, a missing credential, or a failed
+ * probe all resolve to no quota rather than an error.
+ */
+export declare function fetchProviderQuotas(providerId: string, providerType: string | undefined, env?: NodeJS.ProcessEnv): Promise<readonly SessionProviderQuota[]>;

package/dist/client/index.d.ts

@@ -0,0 +1,8 @@
+export { ensureLocalProtocolServer, readTokenIfPresent, runDaemonInProcess, type DaemonRestartRequest, type EnsureLocalProtocolServerOptions, type LocalProtocolServerConnection, } from "./ensureLocalProtocolServer.js";
+export { createUnixSocketFetch } from "../daemon/index.js";
+export { HappyAgentEventHub } from "./HappyAgentEventHub.js";
+export { ensureWorkspaceForCwd, loadAgentCatalog, waitForWorkspaceReady, workspaceForCwd, type AgentCatalog, type AgentCatalogEntry, } from "./loadAgentCatalog.js";
+export { RemoteTerminalAttachment } from "./RemoteTerminalAttachment.js";
+export { RemoteTerminalClientReplica } from "./RemoteTerminalClientReplica.js";
+export { RemoteAgent, type RemoteAgentOptions } from "./RemoteAgent.js";
+export { RemoteAgentRunError } from "./RemoteAgentRunError.js";

package/dist/client/loadAgentCatalog.d.ts

@@ -0,0 +1,32 @@
+import { type Agent, type HappyAgentClient, type Project, type Workspace } from "@slopus/happy-agent-client";
+/** One top-level agent together with the file workspace that owns it. */
+export interface AgentCatalogEntry {
+    agent: Agent;
+    cwd: string;
+    projectId: string;
+    workspaceId: string;
+}
+export interface AgentCatalog {
+    entries: AgentCatalogEntry[];
+    projects: Project[];
+    workspaces: Workspace[];
+}
+/**
+ * Reads the public project/workspace catalogs and flattens their ordered
+ * top-level agent series for terminal pickers.
+ *
+ * There is deliberately no global agent-list call: root agents come from
+ * projects and child-workspace agents come from workspaces.
+ */
+export declare function loadAgentCatalog(client: HappyAgentClient): Promise<AgentCatalog>;
+/** Finds the deepest registered file workspace whose host path is this cwd. */
+export declare function workspaceForCwd(catalog: AgentCatalog, cwd: string): Workspace | Project | undefined;
+/** Registers the cwd as a project only when no public workspace already owns it. */
+export declare function ensureWorkspaceForCwd(client: HappyAgentClient, cwd: string): Promise<Workspace>;
+/**
+ * Resolves the public workspace only after its asynchronous provisioning reaches a usable state.
+ *
+ * `GET /v0/workspaces/:id` deliberately answers `not_initialized` during provisioning. Every
+ * other response is terminal and remains authoritative.
+ */
+export declare function waitForWorkspaceReady(client: Pick<HappyAgentClient, "getWorkspace">, workspaceId: string): Promise<Workspace>;

package/dist/config/createProjectConfigSecurityNotice.d.ts

@@ -0,0 +1,10 @@
+import type { PartialHappyTerminalConfig } from "./types.js";
+/**
+ * The startup notice shown when a project's config file asked for a machine-level setting the
+ * merge refused. Only the permission mode is machine-level in this file's schema; everything
+ * else it may set is an ordinary preference.
+ */
+export declare function createProjectConfigSecurityNotice(config: PartialHappyTerminalConfig, configFileName?: string): {
+    text: string;
+    title: string;
+} | undefined;

package/dist/config/defaultConfig.d.ts

@@ -0,0 +1,2 @@
+import type { HappyTerminalConfig } from "./types.js";
+export declare const DEFAULT_HAPPY_TERMINAL_CONFIG: HappyTerminalConfig;

package/dist/config/getDefaultGlobalConfigPath.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultGlobalConfigPath(env?: NodeJS.ProcessEnv, homeDirectory?: string): string;

package/dist/config/getDefaultLocalConfigPath.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultLocalConfigPath(cwd?: string): string;

package/dist/config/getDefaultRuntimeConfigPath.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultRuntimeConfigPath(env?: NodeJS.ProcessEnv, homeDirectory?: string): string;

package/dist/config/getHappyConfigDirectory.d.ts

@@ -0,0 +1 @@
+export declare function getHappyConfigDirectory(environment?: NodeJS.ProcessEnv, homeDirectory?: string, platform?: NodeJS.Platform): string;

package/dist/config/getHappyTerminalHome.d.ts

@@ -0,0 +1 @@
+export declare function getHappyTerminalHome(environment?: NodeJS.ProcessEnv, homeDirectory?: string): string;

package/dist/config/index.d.ts

@@ -0,0 +1,15 @@
+export { DEFAULT_HAPPY_TERMINAL_CONFIG } from "./defaultConfig.js";
+export { getDefaultGlobalConfigPath } from "./getDefaultGlobalConfigPath.js";
+export { getDefaultLocalConfigPath } from "./getDefaultLocalConfigPath.js";
+export { getDefaultRuntimeConfigPath } from "./getDefaultRuntimeConfigPath.js";
+export { getHappyConfigDirectory } from "./getHappyConfigDirectory.js";
+export { getHappyTerminalHome } from "./getHappyTerminalHome.js";
+export { createProjectConfigSecurityNotice } from "./createProjectConfigSecurityNotice.js";
+export { loadConfig } from "./loadConfig.js";
+export { mergeConfigValues } from "./mergeConfigValues.js";
+export { parseConfigToml, parseConfigTomlWithUnknownSettings, type ParsedConfigToml, } from "./parseConfigToml.js";
+export { resolveConfigPaths } from "./resolveConfigPaths.js";
+export { updateRuntimePreferences } from "./updateRuntimePreferences.js";
+export { writeRuntimeConfig } from "./writeRuntimeConfig.js";
+export { writeRuntimeConfigDefaults } from "./writeRuntimeConfigDefaults.js";
+export type { ConfigDefaults, ConfigPaths, ConfigSettings, ConfigSource, ConfigTheme, LoadedConfig, LoadConfigOptions, PartialConfigDefaults, PartialConfigSettings, PartialConfigTheme, PartialHappyTerminalConfig, HappyTerminalConfig, } from "./types.js";

package/dist/config/loadConfig.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedConfig, LoadConfigOptions } from "./types.js";
+export declare function loadConfig(options?: LoadConfigOptions): Promise<LoadedConfig>;

package/dist/config/mergeConfigValues.d.ts

@@ -0,0 +1,2 @@
+import type { PartialHappyTerminalConfig, HappyTerminalConfig } from "./types.js";
+export declare function mergeConfigValues(base: HappyTerminalConfig, ...configs: readonly PartialHappyTerminalConfig[]): HappyTerminalConfig;

package/dist/config/parseConfigToml.d.ts

@@ -0,0 +1,7 @@
+import type { PartialHappyTerminalConfig } from "./types.js";
+export interface ParsedConfigToml {
+    unknownSettings: readonly string[];
+    values: PartialHappyTerminalConfig;
+}
+export declare function parseConfigToml(source: string): PartialHappyTerminalConfig;
+export declare function parseConfigTomlWithUnknownSettings(source: string): ParsedConfigToml;

package/dist/config/readConfigFile.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigSource } from "./types.js";
+export declare function readConfigFile(path: string): Promise<ConfigSource>;

package/dist/config/readProjectConfigFile.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigSource } from "./types.js";
+export declare function readProjectConfigFile(happyTomlPath: string): Promise<ConfigSource>;

package/dist/config/resolveConfigPaths.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigPaths, LoadConfigOptions } from "./types.js";
+export declare function resolveConfigPaths(options?: LoadConfigOptions): ConfigPaths;

package/dist/config/runtimeConfigLock.d.ts

@@ -0,0 +1 @@
+export declare function runWithRuntimeConfigLock<T>(operation: () => Promise<T>): Promise<T>;

package/dist/config/types.d.ts

@@ -0,0 +1,74 @@
+import type { PermissionMode, ServiceTier } from "../protocol/index.js";
+export interface ConfigDefaults {
+    effort?: string;
+    instructions?: string;
+    modelId: string;
+    permissionMode: PermissionMode;
+    providerId?: string;
+    serviceTier?: ServiceTier;
+}
+export interface PartialConfigDefaults {
+    effort?: string;
+    instructions?: string;
+    modelId?: string;
+    permissionMode?: PermissionMode;
+    providerId?: string;
+    serviceTier?: ServiceTier | null;
+}
+export interface ConfigSettings {
+    compactCompletedTurns: boolean;
+    completionChime: boolean;
+    showReasoning: boolean;
+    showUsage: boolean;
+}
+export interface PartialConfigSettings {
+    compactCompletedTurns?: boolean;
+    completionChime?: boolean;
+    showReasoning?: boolean;
+    showUsage?: boolean;
+}
+export interface ConfigTheme {
+    accent: string;
+    brand: string;
+    error: string;
+    primary: string;
+    secondary: string;
+    success: string;
+    warning: string;
+}
+export type PartialConfigTheme = Partial<ConfigTheme>;
+export interface HappyTerminalConfig {
+    defaults: ConfigDefaults;
+    settings: ConfigSettings;
+    theme: ConfigTheme;
+}
+export interface PartialHappyTerminalConfig {
+    defaults?: PartialConfigDefaults;
+    settings?: PartialConfigSettings;
+    theme?: PartialConfigTheme;
+}
+export interface ConfigPaths {
+    global: string;
+    local: string;
+    runtime: string;
+}
+export interface ConfigSource {
+    exists: boolean;
+    path: string;
+    values: PartialHappyTerminalConfig;
+    unknownSettings: readonly string[];
+}
+export interface LoadedConfig {
+    config: HappyTerminalConfig;
+    paths: ConfigPaths;
+    sources: {
+        global: ConfigSource;
+        local: ConfigSource;
+        runtime: ConfigSource;
+    };
+}
+export interface LoadConfigOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    homeDirectory?: string;
+}

package/dist/config/updateRuntimeConfig.d.ts

@@ -0,0 +1,2 @@
+import type { PartialHappyTerminalConfig } from "./types.js";
+export declare function updateRuntimeConfig(path: string, update: () => Promise<PartialHappyTerminalConfig>): Promise<void>;

package/dist/config/updateRuntimePreferences.d.ts

@@ -0,0 +1,2 @@
+import type { PartialHappyTerminalConfig } from "./types.js";
+export declare function updateRuntimePreferences(path: string, preferences: PartialHappyTerminalConfig): Promise<void>;

package/dist/config/withoutProjectMachineSettings.d.ts

@@ -0,0 +1,7 @@
+import type { PartialHappyTerminalConfig } from "./types.js";
+/**
+ * A checked-in project file may carry preferences, never this machine's permission boundary.
+ * The permission mode is dropped here so a hostile repository cannot elevate the session, and
+ * the startup notice tells the person what was ignored.
+ */
+export declare function withoutProjectMachineSettings(config: PartialHappyTerminalConfig): PartialHappyTerminalConfig;

package/dist/config/writeRuntimeConfig.d.ts

@@ -0,0 +1,3 @@
+import type { PartialHappyTerminalConfig } from "./types.js";
+export declare function writeRuntimeConfig(path: string, config: PartialHappyTerminalConfig): Promise<void>;
+export declare function writeRuntimeConfigInsideLock(path: string, config: PartialHappyTerminalConfig): Promise<void>;

package/dist/config/writeRuntimeConfigDefaults.d.ts

@@ -0,0 +1,2 @@
+import type { PartialConfigDefaults } from "./types.js";
+export declare function writeRuntimeConfigDefaults(path: string, defaults: PartialConfigDefaults): Promise<void>;

package/dist/daemon/createUnixSocketFetch.d.ts

@@ -0,0 +1,2 @@
+/** Adapts the daemon's Unix socket to the Fetch API consumed by HappyAgentClient. */
+export declare function createUnixSocketFetch(socketPath: string): typeof globalThis.fetch;

package/dist/daemon/daemonPid.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from "@steve.kite/stdlib";
+export interface KillDaemonFromPidFileResult {
+    readonly found: boolean;
+    readonly killed: boolean;
+    readonly pid?: number;
+}
+export declare function readDaemonPid(pidPath: string): Promise<number | undefined>;
+export declare function removeDaemonPid(pidPath: string, expectedPid: number): Promise<boolean>;
+export declare function killDaemonFromPidFile(ctx: Context, pidPath: string): Promise<KillDaemonFromPidFileResult>;
+/** Immediately kill one exact daemon PID and wait for the operating system to release it. */
+export declare function killDaemonProcess(ctx: Context, pid: number, timeoutMs?: number): Promise<boolean>;

package/dist/daemon/ensureHappyAgentBinary.d.ts

@@ -0,0 +1,15 @@
+import { type HappyDaemonPaths } from "./getHappyDaemonPaths.js";
+export interface HappyAgentBinary {
+    readonly path: string;
+    readonly version: string;
+}
+export interface EnsureHappyAgentBinaryOptions {
+    arch?: NodeJS.Architecture;
+    extractArchive?: (archivePath: string, destination: string, archivedBinaryName: string) => Promise<void>;
+    fetch?: typeof globalThis.fetch;
+    onStatus?: (message: string) => void;
+    paths?: HappyDaemonPaths;
+    platform?: NodeJS.Platform;
+}
+/** Returns the selected installed release, downloading one only for an empty installation. */
+export declare function ensureHappyAgentBinary(options?: EnsureHappyAgentBinaryOptions): Promise<HappyAgentBinary>;

package/dist/daemon/ensureLocalProtocolServer.d.ts

@@ -0,0 +1,24 @@
+import { HappyAgentClient, type HealthResponse } from "@slopus/happy-agent-client";
+import { type HappyDaemonPaths } from "./getHappyDaemonPaths.js";
+export interface LocalProtocolServerConnection {
+    readonly client: HappyAgentClient;
+    readonly health: HealthResponse;
+    readonly paths: HappyDaemonPaths;
+    readonly token: string;
+}
+export type ObservedLocalProtocolServer = LocalProtocolServerConnection;
+export interface EnsureLocalProtocolServerOptions {
+    onStatus?: (message: string) => void;
+}
+interface LocalHappyAgentSources {
+    cliPath: string;
+    runModuleUrl: string;
+}
+/** Connects to the running daemon, or starts local source/release code when no socket responds. */
+export declare function ensureLocalProtocolServer(options?: EnsureLocalProtocolServerOptions): Promise<LocalProtocolServerConnection>;
+export declare function observeLocalProtocolServer(paths?: HappyDaemonPaths): Promise<ObservedLocalProtocolServer | undefined>;
+export declare function readTokenIfPresent(tokenPath: string): Promise<string | undefined>;
+/** The local Gym keeps the daemon in the TUI process to make full-system scenarios inexpensive. */
+export declare function runDaemonInProcess(environment?: NodeJS.ProcessEnv): boolean;
+export declare function resolveLocalHappyAgentSources(moduleUrl?: string, exists?: (path: URL) => boolean): LocalHappyAgentSources | undefined;
+export {};

package/dist/daemon/getHappyDaemonPaths.d.ts

@@ -0,0 +1,16 @@
+/** Filesystem locations shared by Happy Terminal and the Happy Agent daemon. */
+export interface HappyDaemonPaths {
+    readonly agentDirectory: string;
+    readonly binaryConfigPath: string;
+    readonly distDirectory: string;
+    readonly happyHome: string;
+    readonly installLockPath: string;
+    readonly logPath: string;
+    readonly observationLogPath: string;
+    readonly pidPath: string;
+    readonly socketPath: string;
+    readonly tokenPath: string;
+    readonly versionsDirectory: string;
+}
+export declare function getHappyDaemonPaths(environment?: NodeJS.ProcessEnv, homeDirectory?: string): HappyDaemonPaths;
+export declare function happyAgentBinaryPath(paths: HappyDaemonPaths, version: string): string;

package/dist/daemon/happyAgentBinaryConfig.d.ts

@@ -0,0 +1,15 @@
+import { type Static } from "@sinclair/typebox";
+import { type HappyDaemonPaths } from "./getHappyDaemonPaths.js";
+export declare const SEMANTIC_VERSION_PATTERN = "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$";
+export declare const happyAgentBinaryConfigSchema: import("@sinclair/typebox").TObject<{
+    downloadedVersions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    selectedVersion: import("@sinclair/typebox").TString;
+}>;
+export type HappyAgentBinaryConfig = Static<typeof happyAgentBinaryConfigSchema>;
+export declare function readHappyAgentBinaryConfig(paths: HappyDaemonPaths): Promise<HappyAgentBinaryConfig | undefined>;
+export declare function selectedHappyAgentBinary(paths: HappyDaemonPaths): Promise<{
+    path: string;
+    version: string;
+} | undefined>;
+export declare function writeHappyAgentBinaryConfig(paths: HappyDaemonPaths, selectedVersion: string): Promise<HappyAgentBinaryConfig>;
+export declare function isExecutableFile(path: string): Promise<boolean>;

package/dist/daemon/index.d.ts

@@ -0,0 +1,5 @@
+export { createUnixSocketFetch } from "./createUnixSocketFetch.js";
+export { ensureHappyAgentBinary, type EnsureHappyAgentBinaryOptions, type HappyAgentBinary, } from "./ensureHappyAgentBinary.js";
+export { ensureLocalProtocolServer, observeLocalProtocolServer, readTokenIfPresent, resolveLocalHappyAgentSources, runDaemonInProcess, type EnsureLocalProtocolServerOptions, type LocalProtocolServerConnection, type ObservedLocalProtocolServer, } from "./ensureLocalProtocolServer.js";
+export { getHappyDaemonPaths, happyAgentBinaryPath, type HappyDaemonPaths, } from "./getHappyDaemonPaths.js";
+export { runDaemonCommand, type DaemonCommand } from "./runDaemonCommand.js";

package/dist/daemon/runDaemonCommand.d.ts

@@ -0,0 +1,4 @@
+import { type Context } from "@steve.kite/stdlib";
+export type DaemonCommand = "kill" | "reload" | "start" | "status" | "stop";
+/** Runs one `happy daemon` lifecycle command through the same downloaded/dev daemon path as Happy Terminal. */
+export declare function runDaemonCommand(command: DaemonCommand, log?: (line: string) => void, ctx?: Context): Promise<void>;

package/dist/debug/DebugLog.d.ts

@@ -0,0 +1,11 @@
+export interface DebugLogOptions {
+    directory: string;
+    now?: () => number;
+}
+export declare class DebugLog {
+    #private;
+    readonly directory: string;
+    constructor(options: DebugLogOptions);
+    flush(): Promise<void>;
+    record(type: string, data: unknown): Promise<void>;
+}

package/dist/debug/closeNodeInspector.d.ts

@@ -0,0 +1 @@
+export declare function closeNodeInspector(): boolean;

package/dist/debug/createDebugJsonReplacer.d.ts

@@ -0,0 +1 @@
+export declare function createDebugJsonReplacer(): (key: string, value: unknown) => unknown;

package/dist/debug/createRequestDebugDirectory.d.ts

@@ -0,0 +1 @@
+export declare function createRequestDebugDirectory(cwd: string, runId: string, createdAt: number): string;

package/dist/debug/getDebugRootDirectory.d.ts

@@ -0,0 +1 @@
+export declare function getDebugRootDirectory(cwd: string): string;

package/dist/debug/getNodeInspectorUrl.d.ts

@@ -0,0 +1 @@
+export declare function getNodeInspectorUrl(): string | undefined;

package/dist/debug/index.d.ts

@@ -0,0 +1,8 @@
+export { DebugLog } from "./DebugLog.js";
+export type { DebugLogOptions } from "./DebugLog.js";
+export { createRequestDebugDirectory } from "./createRequestDebugDirectory.js";
+export { closeNodeInspector } from "./closeNodeInspector.js";
+export { getNodeInspectorUrl } from "./getNodeInspectorUrl.js";
+export { getDebugRootDirectory } from "./getDebugRootDirectory.js";
+export { openNodeInspector } from "./openNodeInspector.js";
+export { registerHappyTerminalDebugRoot, type HappyTerminalDebugRoot, } from "./registerHappyTerminalDebugRoot.js";

package/dist/debug/openNodeInspector.d.ts

@@ -0,0 +1 @@
+export declare function openNodeInspector(): string;

package/dist/debug/registerHappyTerminalDebugRoot.d.ts

@@ -0,0 +1,5 @@
+export interface HappyTerminalDebugRoot {
+    kind: "daemon" | "tui";
+    [name: string]: unknown;
+}
+export declare function registerHappyTerminalDebugRoot(root: HappyTerminalDebugRoot): void;