@caplets/core 0.24.1 → 0.25.1

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

@@ -1,5 +1,5 @@
-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 { u as CapletsError } from "./validation-DgxCzt-A.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-Ut6dN9M8.js";
+import { u as CapletsError } from "./validation-C4tYXw6G.js";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { createHash } from "node:crypto";
@@ -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,7 +116,12 @@ const cliSubcommands = {
 		"mcp-client"
 	]
 };
-const capletIdCommands = new Set([
+const cliNestedSubcommands = { [cliCommands.remote]: { host: [
+	"pair",
+	"clients",
+	"revoke"
+] } };
+const capletIdCommands = /* @__PURE__ */ new Set([
 	cliCommands.inspect,
 	cliCommands.checkBackend,
 	cliCommands.listTools,
@@ -118,8 +134,8 @@ const capletIdCommands = new Set([
 	cliCommands.searchPrompts,
 	cliCommands.complete
 ]);
-const qualifiedToolCommands = new Set([cliCommands.getTool, cliCommands.callTool]);
-const qualifiedPromptCommands = new Set([cliCommands.getPrompt]);
+const qualifiedToolCommands = /* @__PURE__ */ new Set([cliCommands.getTool, cliCommands.callTool]);
+const qualifiedPromptCommands = /* @__PURE__ */ new Set([cliCommands.getPrompt]);
 //#endregion
 //#region src/cli/inspection.ts
 function listCaplets(configWithSources, options) {
@@ -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,7 +553,11 @@ function suggestionsForOptionValue(command, subcommand, previous) {
 	if (!previous) return void 0;
 	return optionValueSuggestions[`${command}:${subcommand}`]?.[previous] ?? optionValueSuggestions[command]?.[previous] ?? optionValueSuggestions["*"]?.[previous];
 }
-const promptResourceCommands = new Set([
+function nestedSubcommandsFor(command, subcommand) {
+	if (command !== cliCommands.remote || subcommand !== "host") return void 0;
+	return cliNestedSubcommands.remote.host;
+}
+const promptResourceCommands = /* @__PURE__ */ new Set([
 	cliCommands.getPrompt,
 	cliCommands.readResource,
 	cliCommands.complete

package/dist/config-runtime.js

@@ -1,5 +1,5 @@
-import { _ as record, b as unknown, d as literal, l as discriminatedUnion, m as object, o as array, p as number, r as _enum, s as boolean, v as string, y as union } from "./schemas-C0PNPwjS.js";
-import { a as isAllowedHttpBaseUrl, c as validateHttpActionHeaders, i as SERVER_ID_PATTERN, n as HEADER_NAME_PATTERN, o as isAllowedRemoteUrl, r as HTTP_BASE_URL_PATTERN, s as isUrl, t as FORBIDDEN_HEADERS, u as CapletsError } from "./validation-DgxCzt-A.js";
+import { _ as record, b as unknown, d as literal, l as discriminatedUnion, m as object, o as array, p as number, r as _enum, s as boolean, v as string, y as union } from "./schemas-BoqMu4MG.js";
+import { a as isAllowedHttpBaseUrl, c as validateHttpActionHeaders, i as SERVER_ID_PATTERN, n as HEADER_NAME_PATTERN, o as isAllowedRemoteUrl, r as HTTP_BASE_URL_PATTERN, s as isUrl, t as FORBIDDEN_HEADERS, u as CapletsError } from "./validation-C4tYXw6G.js";
 //#region src/config-runtime.ts
 const stringMapSchema = record(string(), string());
 const authSchema = discriminatedUnion("type", [

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,14 @@
+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;
+    skipBindHostValidation?: boolean;
+    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;

package/dist/generated-tool-input-schema.js

@@ -1,4 +1,4 @@
-import { a as any, d as literal, m as object, o as array, p as number, r as _enum, v as string, y as union } from "./schemas-C0PNPwjS.js";
+import { a as any, d as literal, m as object, o as array, p as number, r as _enum, v as string, y as union } from "./schemas-BoqMu4MG.js";
 //#region src/generated-tool-input-schema.ts
 const operations = [
 	"inspect",