@caplets/core 0.24.1 → 0.25.0

package/dist/attach/options.d.ts

@@ -7,6 +7,7 @@ export type AttachServeOptions = ServeOptions & {
     configPath: string;
     projectRoot: string;
     projectConfigPath: string;
+    authDir?: string | undefined;
     selection: ResolvedRemoteSelection;
 };
 export declare function resolveAttachServeOptions(raw?: RawAttachServeOptions, env?: Record<string, string | undefined>): Promise<AttachServeOptions>;

package/dist/attach/server.d.ts

@@ -3,3 +3,6 @@ export type AttachServeIo = {
     writeErr?: (value: string) => void;
 };
 export declare function attachResolvedCaplets(options: AttachServeOptions, io?: AttachServeIo): Promise<void>;
+declare function createAttachNativeService(options: AttachServeOptions, io: AttachServeIo): import("../native").NativeCapletsService;
+export declare const createAttachNativeServiceForTests: typeof createAttachNativeService;
+export {};

package/dist/cli/commands.d.ts

@@ -4,8 +4,10 @@ export declare const cliCommands: {
     readonly completion: "completion";
     readonly completeHidden: "__complete";
     readonly codeMode: "code-mode";
+    readonly daemon: "daemon";
     readonly serve: "serve";
     readonly attach: "attach";
+    readonly remote: "remote";
     readonly cloud: "cloud";
     readonly init: "init";
     readonly setup: "setup";
@@ -30,17 +32,23 @@ export declare const cliCommands: {
     readonly config: "config";
     readonly auth: "auth";
 };
-export declare const topLevelCommandNames: readonly ["serve", "code-mode", "attach", "cloud", "init", "setup", "doctor", "list", "install", "add", "inspect", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "completion"];
+export declare const topLevelCommandNames: readonly ["serve", "daemon", "code-mode", "attach", "remote", "cloud", "init", "setup", "doctor", "list", "install", "add", "inspect", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "completion"];
 export declare const cliSubcommands: {
     readonly add: readonly ["cli", "mcp", "openapi", "google-discovery", "graphql", "http"];
     readonly auth: readonly ["login", "logout", "list", "refresh"];
     readonly cloud: readonly ["auth"];
+    readonly remote: readonly ["login", "status", "logout", "host"];
     readonly "code-mode": readonly ["types"];
     readonly completion: readonly ["bash", "zsh", "fish", "powershell", "cmd"];
     readonly config: readonly ["path", "paths"];
-    readonly serve: readonly ["start", "stop", "status", "restart", "enable", "disable"];
+    readonly daemon: readonly ["install", "uninstall", "start", "restart", "stop", "status", "logs"];
     readonly setup: readonly ["codex", "claude-code", "opencode", "pi", "mcp-client"];
 };
+export declare const cliNestedSubcommands: {
+    readonly remote: {
+        readonly host: readonly ["pair", "clients", "revoke"];
+    };
+};
 export declare const capletIdCommands: Set<string>;
 export declare const qualifiedToolCommands: Set<string>;
 export declare const qualifiedPromptCommands: Set<string>;

package/dist/cli/doctor.d.ts

@@ -1,11 +1,14 @@
 import { CloudAuthStore } from "../cloud-auth/store";
 import type { MutagenProjectSyncDoctorData } from "../project-binding/mutagen";
+import { type DaemonOperationOptions } from "../daemon";
 export type DoctorOptions = {
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     cwd?: string;
     syncStatus?: MutagenProjectSyncDoctorData;
     cloudAuthStore?: CloudAuthStore;
+    authDir?: string;
     observedOutputShapeCacheDir?: string;
+    daemon?: DaemonOperationOptions;
 };
 export type DoctorJsonReport = {
     server: Record<string, unknown>;
@@ -13,7 +16,7 @@ export type DoctorJsonReport = {
     projectBinding: Record<string, unknown>;
     sync: Record<string, unknown>;
     daemon: Record<string, unknown>;
-    cloudAuth: Record<string, unknown>;
+    remoteLogin: Record<string, unknown>;
     exposure: Record<string, unknown>;
     codeMode: Record<string, unknown>;
 };

package/dist/cli.d.ts

@@ -2,7 +2,8 @@ import { Command } from "commander";
 import { type SetupCommandRunner } from "./cli/setup";
 import { type AttachServeOptions } from "./attach/options";
 import type { ProjectBindingWebSocketFactory } from "./project-binding/transport";
-import { type ServeDaemonOperationOptions, type ServeOptions } from "./serve";
+import { type DaemonOperationOptions } from "./daemon";
+import { type ServeOptions } from "./serve";
 export { initConfig, starterConfig } from "./cli/init";
 export { installCaplets, normalizeGitRepo } from "./cli/install";
 export { addCliCaplet, addGoogleDiscoveryCaplet, addGraphqlCaplet, addHttpCaplet, addMcpCaplet, addOpenApiCaplet, } from "./cli/add";
@@ -18,7 +19,7 @@ type CliIO = {
     setExitCode?: (code: number) => void;
     serve?: (options: ServeOptions) => Promise<void>;
     attachServe?: (options: AttachServeOptions) => Promise<void>;
-    daemon?: ServeDaemonOperationOptions;
+    daemon?: DaemonOperationOptions;
     runSetupCommand?: SetupCommandRunner;
     readStdin?: () => Promise<string>;
 };

package/dist/{completion-BeVXdm9q.js → completion-DrPr2vYw.js}

@@ -1,4 +1,4 @@
-import { Dt as resolveConfigPath, Et as resolveCapletsRoot, Tn as __exportAll, bt as DEFAULT_AUTH_DIR, kt as resolveProjectConfigPath, tt as loadConfigWithSources, xt as DEFAULT_COMPLETION_CACHE_DIR } from "./service-Cvnuu9wr.js";
+import { Dt as DEFAULT_AUTH_DIR, Ft as resolveConfigPath, Lt as resolveProjectConfigPath, Nn as __exportAll, Ot as DEFAULT_COMPLETION_CACHE_DIR, Pt as resolveCapletsRoot, ct as loadConfigWithSources } from "./service-DjwB8aiW.js";
 import { u as CapletsError } from "./validation-DgxCzt-A.js";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -15,8 +15,10 @@ const cliCommands = {
 	completion: "completion",
 	completeHidden: "__complete",
 	codeMode: "code-mode",
+	daemon: "daemon",
 	serve: "serve",
 	attach: "attach",
+	remote: "remote",
 	cloud: "cloud",
 	init: "init",
 	setup: "setup",
@@ -43,8 +45,10 @@ const cliCommands = {
 };
 const topLevelCommandNames = [
 	cliCommands.serve,
+	cliCommands.daemon,
 	cliCommands.codeMode,
 	cliCommands.attach,
+	cliCommands.remote,
 	cliCommands.cloud,
 	cliCommands.init,
 	cliCommands.setup,
@@ -86,16 +90,23 @@ const cliSubcommands = {
 		"refresh"
 	],
 	[cliCommands.cloud]: ["auth"],
+	[cliCommands.remote]: [
+		"login",
+		"status",
+		"logout",
+		"host"
+	],
 	[cliCommands.codeMode]: ["types"],
 	[cliCommands.completion]: [...completionShells],
 	[cliCommands.config]: ["path", "paths"],
-	[cliCommands.serve]: [
+	[cliCommands.daemon]: [
+		"install",
+		"uninstall",
 		"start",
+		"restart",
 		"stop",
 		"status",
-		"restart",
-		"enable",
-		"disable"
+		"logs"
 	],
 	[cliCommands.setup]: [
 		"codex",
@@ -105,6 +116,11 @@ const cliSubcommands = {
 		"mcp-client"
 	]
 };
+const cliNestedSubcommands = { [cliCommands.remote]: { host: [
+	"pair",
+	"clients",
+	"revoke"
+] } };
 const capletIdCommands = new Set([
 	cliCommands.inspect,
 	cliCommands.checkBackend,
@@ -511,6 +527,8 @@ async function completeCliWords(words, options = {}) {
 		if (optionValues) return prefixFilter(optionValues, current);
 		if (normalized.length === 1) return prefixFilter([...topLevelCommandNames], current);
 		if (normalized.length === 2 && command in cliSubcommands) return prefixFilter(cliSubcommands[command], current);
+		const nestedStaticSubcommands = nestedSubcommandsFor(command, subcommand);
+		if (normalized.length === 3 && nestedStaticSubcommands) return prefixFilter(nestedStaticSubcommands, current);
 		if (normalized.length === 2 && capletIdCommands.has(command)) return prefixFilter(promptResourceCommands.has(command) ? configuredCapletIds(options, { backend: "mcp" }) : configuredCapletIds(options), current);
 		if (qualifiedToolCommands.has(command) || qualifiedPromptCommands.has(command)) {
 			const kind = qualifiedToolCommands.has(command) ? "tools" : "prompts";
@@ -535,6 +553,10 @@ function suggestionsForOptionValue(command, subcommand, previous) {
 	if (!previous) return void 0;
 	return optionValueSuggestions[`${command}:${subcommand}`]?.[previous] ?? optionValueSuggestions[command]?.[previous] ?? optionValueSuggestions["*"]?.[previous];
 }
+function nestedSubcommandsFor(command, subcommand) {
+	if (command !== cliCommands.remote || subcommand !== "host") return void 0;
+	return cliNestedSubcommands.remote.host;
+}
 const promptResourceCommands = new Set([
 	cliCommands.getPrompt,
 	cliCommands.readResource,

package/dist/daemon/config.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonConfig, DaemonEnvConfig, DaemonInstallOptions, DaemonPaths, DaemonState } from "./types";
+export declare function readDaemonConfig(paths: DaemonPaths): DaemonConfig | undefined;
+export declare function writeDaemonConfig(paths: DaemonPaths, config: DaemonConfig): DaemonConfig;
+export declare function readDaemonState(paths: DaemonPaths): DaemonState | undefined;
+export declare function writeDaemonState(paths: DaemonPaths, state: DaemonState): DaemonState;
+export declare function removeDaemonConfig(paths: DaemonPaths): void;
+export declare function removeDaemonState(paths: DaemonPaths): void;
+export declare function mergeDaemonEnv(existing: DaemonEnvConfig | undefined, install: Pick<DaemonInstallOptions, "env" | "unsetEnv" | "inheritEnv">): DaemonEnvConfig;

package/dist/daemon/env.d.ts

@@ -0,0 +1,2 @@
+import type { DaemonOperationOptions, DaemonShellPlan } from "./types";
+export declare function resolveDaemonShell(options: Pick<DaemonOperationOptions, "env" | "platform" | "accountShell">): DaemonShellPlan;

package/dist/daemon/index.d.ts

@@ -0,0 +1,18 @@
+import type { DaemonInstallOptions, DaemonInstallResult, DaemonLifecycleResult, DaemonLogStream, DaemonLogsResult, DaemonOperationOptions, DaemonStatus, DaemonUninstallOptions, DaemonUninstallResult } from "./types";
+export declare function installDaemon(install?: DaemonInstallOptions, options?: DaemonOperationOptions): Promise<DaemonInstallResult>;
+export declare function uninstallDaemon(uninstall?: DaemonUninstallOptions, options?: DaemonOperationOptions): Promise<DaemonUninstallResult>;
+export declare function startDaemon(options?: DaemonOperationOptions): Promise<DaemonLifecycleResult>;
+export declare function restartDaemon(options?: DaemonOperationOptions): Promise<DaemonLifecycleResult>;
+export declare function stopDaemon(options?: DaemonOperationOptions): Promise<DaemonLifecycleResult>;
+export declare function daemonStatus(options?: DaemonOperationOptions): Promise<DaemonStatus>;
+export declare function redactDaemonInstallResult(result: DaemonInstallResult): DaemonInstallResult;
+export declare function daemonLogs(options?: DaemonOperationOptions & {
+    stream?: DaemonLogStream;
+    tail?: number;
+}): DaemonLogsResult;
+export { resolveDaemonPaths } from "./paths";
+export { resolveDaemonHttpServeOptions, daemonServeArgs } from "./process";
+export { readDaemonConfig, readDaemonState } from "./config";
+export { createNativeDaemonManager } from "./manager";
+export { followDaemonLogs } from "./logs";
+export type { DaemonCommandPlan, DaemonCommandRunner, DaemonConfig, DaemonDescriptor, DaemonInstallOptions, DaemonLogEntry, DaemonLogStream, DaemonLogsResult, DaemonManager, DaemonOperationOptions, DaemonPaths, DaemonStatus, NativeDaemonStatus, RawDaemonServeOptions, } from "./types";

package/dist/daemon/logs.d.ts

@@ -0,0 +1,15 @@
+import type { DaemonLogEntry, DaemonLogStream, DaemonLogsResult, DaemonPaths } from "./types";
+export declare function readDaemonLogs(paths: DaemonPaths, options?: {
+    stream?: DaemonLogStream;
+    tail?: number;
+}): DaemonLogsResult;
+export declare function followDaemonLogs(paths: DaemonPaths, options: {
+    stream?: DaemonLogStream;
+    tail?: number;
+    write: (entry: DaemonLogEntry | {
+        type: "metadata";
+        paths: Pick<DaemonPaths, "stdoutLog" | "stderrLog">;
+    }) => void;
+    signal?: AbortSignal;
+}): Promise<void>;
+export declare function ensureDaemonLogFiles(paths: DaemonPaths): void;

package/dist/daemon/manager.d.ts

@@ -0,0 +1,2 @@
+import type { DaemonManager, DaemonOperationOptions } from "./types";
+export declare function createNativeDaemonManager(options?: DaemonOperationOptions): DaemonManager;

package/dist/daemon/paths.d.ts

@@ -0,0 +1,2 @@
+import type { DaemonOperationOptions, DaemonPaths } from "./types";
+export declare function resolveDaemonPaths(options?: Pick<DaemonOperationOptions, "env" | "home" | "platform">): DaemonPaths;

package/dist/daemon/platform-darwin.d.ts

@@ -0,0 +1,3 @@
+import type { DaemonConfig, DaemonDescriptor } from "./types";
+export declare const LAUNCHD_LABEL = "dev.caplets.daemon.default";
+export declare function buildLaunchdDescriptor(config: DaemonConfig): DaemonDescriptor;

package/dist/daemon/platform-linux.d.ts

@@ -0,0 +1,3 @@
+import type { DaemonConfig, DaemonDescriptor } from "./types";
+export declare const SYSTEMD_UNIT = "caplets-daemon-default.service";
+export declare function buildSystemdDescriptor(config: DaemonConfig): DaemonDescriptor;

package/dist/daemon/platform-windows.d.ts

@@ -0,0 +1,3 @@
+import type { DaemonConfig, DaemonDescriptor } from "./types";
+export declare const WINDOWS_TASK_NAME = "\\Caplets\\daemon-default";
+export declare function buildWindowsTaskDescriptor(config: DaemonConfig): DaemonDescriptor;

package/dist/daemon/process.d.ts

@@ -0,0 +1,11 @@
+import { type HttpServeOptions } from "../serve/options";
+import type { DaemonCommandPlan, DaemonOperationOptions, DaemonPaths, RawDaemonServeOptions } from "./types";
+export declare function resolveDaemonHttpServeOptions(raw: RawDaemonServeOptions, env?: NodeJS.ProcessEnv | Record<string, string | undefined>): HttpServeOptions;
+export declare function daemonServeArgs(options: HttpServeOptions): string[];
+export declare function buildDaemonCommandPlan(options: {
+    serve: HttpServeOptions;
+    paths: DaemonPaths;
+    operation: Pick<DaemonOperationOptions, "env" | "home" | "platform" | "accountShell">;
+    explicitEnv?: Record<string, string>;
+    inheritEnv?: boolean;
+}): DaemonCommandPlan;

package/dist/daemon/shell.d.ts

@@ -0,0 +1,20 @@
+export declare function shellQuote(value: string): string;
+export declare function serviceCommand(config: {
+    command: {
+        executable: string;
+        args: string[];
+        env?: Record<string, string>;
+        shell?: {
+            executable: string;
+            args: string[];
+        };
+    };
+}): {
+    executable: string;
+    args: string[];
+    display: string;
+};
+export declare function shellCommandLine(shell: {
+    executable: string;
+    args: string[];
+}, argv: string[], env?: Record<string, string>): string;

package/dist/daemon/types.d.ts

@@ -0,0 +1,178 @@
+import type { HttpServeOptions, RawServeOptions } from "../serve/options";
+export type DaemonInstance = "default";
+export type RawDaemonServeOptions = Omit<RawServeOptions, "transport"> & {
+    preserveUnauthenticatedAuth?: boolean;
+};
+export type DaemonPaths = {
+    instance: DaemonInstance;
+    stateDir: string;
+    logDir: string;
+    stateFile: string;
+    stdoutLog: string;
+    stderrLog: string;
+    configFile: string;
+    descriptorFile: string;
+    wrapperFile: string;
+};
+export type DaemonEnvConfig = {
+    inherit: boolean;
+    values: Record<string, string>;
+};
+export type DaemonShellPlan = {
+    executable: string;
+    args: string[];
+    source: "SHELL" | "account" | "fallback";
+};
+export type DaemonCommandPlan = {
+    executable: string;
+    args: string[];
+    workingDirectory: string;
+    env: Record<string, string>;
+    inheritEnv: boolean;
+    stdoutLog: string;
+    stderrLog: string;
+    shell?: DaemonShellPlan;
+};
+export type DaemonConfig = {
+    instance: DaemonInstance;
+    serve: HttpServeOptions;
+    command: DaemonCommandPlan;
+    env: DaemonEnvConfig;
+    paths: DaemonPaths;
+    updatedAt: string;
+};
+export type DaemonState = {
+    instance: DaemonInstance;
+    installed: boolean;
+    running: boolean;
+    nativeState: NativeDaemonStateName;
+    updatedAt: string;
+    startedAt?: string;
+    pid?: number;
+};
+export type NativeDaemonStateName = "not_installed" | "installed_stopped" | "running" | "failed" | "unavailable" | "unknown";
+export type NativeDaemonStatus = {
+    state: NativeDaemonStateName;
+    installed: boolean;
+    running: boolean;
+    pid?: number;
+    raw?: Record<string, unknown>;
+    message?: string;
+};
+export type DaemonStatus = {
+    instance: DaemonInstance;
+    installed: boolean;
+    running: boolean;
+    nativeState: NativeDaemonStateName;
+    paths: DaemonPaths;
+    config?: DaemonConfig;
+    native: NativeDaemonStatus;
+    health?: DaemonHealthResult;
+};
+export type DaemonHealthResult = {
+    ok: boolean;
+    url: string;
+    status?: number;
+    error?: string;
+};
+export type DaemonDescriptor = {
+    kind: "launchd-user-agent";
+    label: string;
+    path: string;
+    contents: string;
+} | {
+    kind: "systemd-user";
+    unitName: string;
+    path: string;
+    contents: string;
+} | {
+    kind: "windows-scheduled-task";
+    taskName: string;
+    path: string;
+    command: string;
+    xml: string;
+    wrapper: {
+        path: string;
+        contents: string;
+    };
+};
+export type DaemonManager = {
+    descriptor(config: DaemonConfig): DaemonDescriptor;
+    status(config: DaemonConfig | undefined, paths: DaemonPaths): Promise<NativeDaemonStatus>;
+    install(config: DaemonConfig): Promise<DaemonManagerAction>;
+    uninstall(config: DaemonConfig | undefined, paths: DaemonPaths): Promise<DaemonManagerAction>;
+    start(config: DaemonConfig): Promise<DaemonManagerAction>;
+    restart(config: DaemonConfig): Promise<DaemonManagerAction>;
+    stop(config?: DaemonConfig): Promise<DaemonManagerAction>;
+};
+export type DaemonManagerAction = {
+    action: string;
+    native: NativeDaemonStatus;
+    commands?: string[][];
+    descriptor?: DaemonDescriptor;
+};
+export type DaemonCommandRunner = {
+    exec(command: string, args: string[]): Promise<{
+        stdout: string;
+        stderr: string;
+        code: number;
+    }>;
+};
+export type DaemonOperationOptions = {
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    home?: string;
+    platform?: NodeJS.Platform;
+    manager?: DaemonManager;
+    commandRunner?: DaemonCommandRunner;
+    fetch?: typeof fetch;
+    validateCommand?: (config: DaemonConfig) => Promise<DaemonHealthResult>;
+    accountShell?: string;
+    serviceAvailable?: boolean;
+    uid?: number;
+    now?: Date;
+    readPrompt?: (prompt: string) => Promise<string>;
+    isInteractive?: boolean;
+    healthTimeoutMs?: number;
+    healthIntervalMs?: number;
+};
+export type DaemonInstallOptions = RawDaemonServeOptions & {
+    reset?: boolean;
+    env?: string[];
+    unsetEnv?: string[];
+    inheritEnv?: boolean;
+    dryRun?: boolean;
+    validate?: boolean;
+    start?: boolean;
+    restart?: boolean;
+    noRestart?: boolean;
+};
+export type DaemonUninstallOptions = {
+    purge?: boolean;
+    dryRun?: boolean;
+};
+export type DaemonLifecycleResult = {
+    action: string;
+    status: DaemonStatus;
+    native?: DaemonManagerAction;
+};
+export type DaemonInstallResult = DaemonLifecycleResult & {
+    config: DaemonConfig;
+    descriptor: DaemonDescriptor;
+    validation?: DaemonHealthResult;
+    dryRun: boolean;
+    plannedActions: string[];
+};
+export type DaemonUninstallResult = DaemonLifecycleResult & {
+    purge: boolean;
+    dryRun: boolean;
+    removed: string[];
+};
+export type DaemonLogStream = "stdout" | "stderr" | "all";
+export type DaemonLogEntry = {
+    stream: "stdout" | "stderr";
+    line: string;
+};
+export type DaemonLogsResult = {
+    paths: Pick<DaemonPaths, "stdoutLog" | "stderrLog">;
+    entries: DaemonLogEntry[];
+};

package/dist/daemon/validation.d.ts

@@ -0,0 +1,13 @@
+import type { DaemonConfig, DaemonHealthResult } from "./types";
+export declare function validateDaemonCommand(config: DaemonConfig, options?: {
+    fetch?: typeof fetch;
+    successSettleMs?: number;
+    timeoutMs?: number;
+}): Promise<DaemonHealthResult>;
+export declare function probeDaemonHealth(config: DaemonConfig, options?: {
+    fetch?: typeof fetch;
+    port?: number;
+    timeoutMs?: number;
+}): Promise<DaemonHealthResult>;
+export declare function assertDaemonHealth(result: DaemonHealthResult, label: string): void;
+export declare function allocateLoopbackPort(): Promise<number>;

package/dist/daemon/xml.d.ts

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