@gaodefa/daocore 2026.5.29 → 2026.5.31

package/dist/core-DM2Ct83m.d.ts

@@ -0,0 +1,224 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { T as ReplyToMode } from "./types.base-tQh4FMBR.js";
+import { n as ChannelConfigSchema } from "./types.config-CKJTcS4X.js";
+import { n as ChatChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { b as OutboundDeliveryResult, n as ChannelOutboundAdapter } from "./outbound.types-B2wXms-j.js";
+import { A as ChannelPollResult, D as ChannelOutboundSessionRoute, E as ChannelMeta, R as ChannelThreadingAdapter, T as ChannelMessagingAdapter } from "./types.core-DpVp9PoP.js";
+import { l as DaoCorePluginApi } from "./types-iT2EyaH92.js";
+import { V as ChannelSecurityAdapter } from "./types.adapters-StiSC8e-.js";
+import { t as ChannelPairingAdapter } from "./pairing.types-CQONFSHw.js";
+import { n as ChannelPlugin } from "./types.public-M7pcmtBD.js";
+import { n as PluginRuntime } from "./types-CqkHo5uy.js";
+import { n as ResolvedConfiguredAcpBinding } from "./persistent-bindings.resolve-Dkw984GL.js";
+//#region src/shared/gateway-bind-url.d.ts
+type GatewayBindUrlResult = {
+  url: string;
+  source: "gateway.bind=custom" | "gateway.bind=tailnet" | "gateway.bind=lan";
+} | {
+  error: string;
+} | null;
+declare function resolveGatewayBindUrl(params: {
+  bind?: string;
+  customBindHost?: string;
+  scheme: "ws" | "wss";
+  port: number;
+  pickTailnetHost: () => string | null;
+  pickLanHost: () => string | null;
+}): GatewayBindUrlResult;
+//#endregion
+//#region src/shared/tailscale-status.d.ts
+type TailscaleStatusCommandResult = {
+  code: number | null;
+  stdout: string;
+};
+type TailscaleStatusCommandRunner = (argv: string[], opts: {
+  timeoutMs: number;
+}) => Promise<TailscaleStatusCommandResult>;
+declare function resolveTailnetHostWithRunner(runCommandWithTimeout?: TailscaleStatusCommandRunner): Promise<string | null>;
+//#endregion
+//#region src/plugin-sdk/core.d.ts
+declare function ensureConfiguredAcpBindingReady(params: {
+  cfg: DaoCoreConfig;
+  configuredBinding: ResolvedConfiguredAcpBinding | null;
+}): Promise<{
+  ok: true;
+} | {
+  ok: false;
+  error: string;
+}>;
+type ChannelOutboundSessionRouteParams = Parameters<NonNullable<ChannelMessagingAdapter["resolveOutboundSessionRoute"]>>[0];
+declare function getChatChannelMeta(id: ChatChannelId): ChannelMeta;
+/** Remove one of the known provider prefixes from a free-form target string. */
+declare function stripChannelTargetPrefix(raw: string, ...providers: string[]): string;
+/** Remove generic target-kind prefixes such as `user:` or `group:`. */
+declare function stripTargetKindPrefix(raw: string): string;
+/**
+ * Build the canonical outbound session route payload returned by channel
+ * message adapters.
+ */
+declare function buildChannelOutboundSessionRoute(params: {
+  cfg: DaoCoreConfig;
+  agentId: string;
+  channel: string;
+  accountId?: string | null;
+  peer: {
+    kind: "direct" | "group" | "channel";
+    id: string;
+  };
+  chatType: "direct" | "group" | "channel";
+  from: string;
+  to: string;
+  threadId?: string | number;
+}): ChannelOutboundSessionRoute;
+type ThreadAwareOutboundSessionRouteThreadSource = "replyToId" | "threadId" | "currentSession";
+type ThreadAwareOutboundSessionRouteRecoveryContext = {
+  route: ChannelOutboundSessionRoute;
+  currentBaseSessionKey: string;
+  currentThreadId: string;
+};
+declare function recoverCurrentThreadSessionId(params: {
+  route: ChannelOutboundSessionRoute;
+  currentSessionKey?: string | null;
+  canRecover?: (context: ThreadAwareOutboundSessionRouteRecoveryContext) => boolean;
+}): string | undefined;
+declare function buildThreadAwareOutboundSessionRoute(params: {
+  route: ChannelOutboundSessionRoute;
+  replyToId?: string | number | null;
+  threadId?: string | number | null;
+  currentSessionKey?: string | null;
+  precedence?: readonly ThreadAwareOutboundSessionRouteThreadSource[];
+  useSuffix?: boolean;
+  parentSessionKey?: string;
+  normalizeThreadId?: (threadId: string) => string;
+  canRecoverCurrentThread?: (context: ThreadAwareOutboundSessionRouteRecoveryContext) => boolean;
+}): ChannelOutboundSessionRoute;
+/** Options for a channel plugin entry that should register a channel capability. */
+type ChannelEntryConfigSchema<TPlugin> = TPlugin extends ChannelPlugin<unknown> ? NonNullable<TPlugin["configSchema"]> : ChannelConfigSchema;
+type DefineChannelPluginEntryOptions<TPlugin = ChannelPlugin> = {
+  id: string;
+  name: string;
+  description: string;
+  plugin: TPlugin;
+  configSchema?: ChannelEntryConfigSchema<TPlugin> | (() => ChannelEntryConfigSchema<TPlugin>);
+  setRuntime?: (runtime: PluginRuntime) => void;
+  registerCliMetadata?: (api: DaoCorePluginApi) => void;
+  registerFull?: (api: DaoCorePluginApi) => void;
+};
+type DefinedChannelPluginEntry<TPlugin> = {
+  id: string;
+  name: string;
+  description: string;
+  configSchema: ChannelEntryConfigSchema<TPlugin>;
+  register: (api: DaoCorePluginApi) => void;
+  channelPlugin: TPlugin;
+  setChannelRuntime?: (runtime: PluginRuntime) => void;
+};
+type CreateChannelPluginBaseOptions<TResolvedAccount> = {
+  id: ChannelPlugin<TResolvedAccount>["id"];
+  meta?: Partial<NonNullable<ChannelPlugin<TResolvedAccount>["meta"]>>;
+  setupWizard?: NonNullable<ChannelPlugin<TResolvedAccount>["setupWizard"]>;
+  capabilities?: ChannelPlugin<TResolvedAccount>["capabilities"];
+  commands?: ChannelPlugin<TResolvedAccount>["commands"];
+  doctor?: ChannelPlugin<TResolvedAccount>["doctor"];
+  agentPrompt?: ChannelPlugin<TResolvedAccount>["agentPrompt"];
+  streaming?: ChannelPlugin<TResolvedAccount>["streaming"];
+  reload?: ChannelPlugin<TResolvedAccount>["reload"];
+  gatewayMethods?: ChannelPlugin<TResolvedAccount>["gatewayMethods"];
+  gatewayMethodDescriptors?: ChannelPlugin<TResolvedAccount>["gatewayMethodDescriptors"];
+  configSchema?: ChannelPlugin<TResolvedAccount>["configSchema"];
+  config?: ChannelPlugin<TResolvedAccount>["config"];
+  security?: ChannelPlugin<TResolvedAccount>["security"];
+  setup: NonNullable<ChannelPlugin<TResolvedAccount>["setup"]>;
+  groups?: ChannelPlugin<TResolvedAccount>["groups"];
+};
+type CreatedChannelPluginBase<TResolvedAccount> = Pick<ChannelPlugin<TResolvedAccount>, "id" | "meta" | "setup"> & Partial<Pick<ChannelPlugin<TResolvedAccount>, "setupWizard" | "capabilities" | "commands" | "doctor" | "agentPrompt" | "streaming" | "reload" | "gatewayMethods" | "gatewayMethodDescriptors" | "configSchema" | "config" | "security" | "groups">>;
+/**
+ * Canonical entry helper for channel plugins.
+ *
+ * This wraps `definePluginEntry(...)`, registers the channel capability, and
+ * optionally exposes extra full-runtime registration such as tools or gateway
+ * handlers that only make sense outside setup-only registration modes.
+ */
+declare function defineChannelPluginEntry<TPlugin>({
+  id,
+  name,
+  description,
+  plugin,
+  configSchema,
+  setRuntime,
+  registerCliMetadata,
+  registerFull
+}: DefineChannelPluginEntryOptions<TPlugin>): DefinedChannelPluginEntry<TPlugin>;
+/**
+ * Minimal setup-entry helper for channels that ship a separate `setup-entry.ts`.
+ *
+ * The setup entry only needs to export `{ plugin }`, but using this helper
+ * keeps the shape explicit in examples and generated typings.
+ */
+declare function defineSetupPluginEntry<TPlugin>(plugin: TPlugin): {
+  plugin: TPlugin;
+};
+type ChatChannelPluginBase<TResolvedAccount, Probe, Audit> = Omit<ChannelPlugin<TResolvedAccount, Probe, Audit>, "security" | "pairing" | "threading" | "outbound"> & Partial<Pick<ChannelPlugin<TResolvedAccount, Probe, Audit>, "security" | "pairing" | "threading" | "outbound">>;
+type ChatChannelSecurityOptions<TResolvedAccount extends {
+  accountId?: string | null;
+}> = {
+  dm: {
+    channelKey: string;
+    resolvePolicy: (account: TResolvedAccount) => string | null | undefined;
+    resolveAllowFrom: (account: TResolvedAccount) => Array<string | number> | null | undefined;
+    resolveFallbackAccountId?: (account: TResolvedAccount) => string | null | undefined;
+    defaultPolicy?: string;
+    allowFromPathSuffix?: string;
+    policyPathSuffix?: string;
+    approveChannelId?: string;
+    approveHint?: string;
+    normalizeEntry?: (raw: string) => string;
+    inheritSharedDefaultsFromDefaultAccount?: boolean;
+  };
+  collectWarnings?: ChannelSecurityAdapter<TResolvedAccount>["collectWarnings"];
+  collectAuditFindings?: ChannelSecurityAdapter<TResolvedAccount>["collectAuditFindings"];
+};
+type ChatChannelPairingOptions = {
+  text: {
+    idLabel: string;
+    message: string;
+    normalizeAllowEntry?: ChannelPairingAdapter["normalizeAllowEntry"];
+    notify: (params: Parameters<NonNullable<ChannelPairingAdapter["notifyApproval"]>>[0] & {
+      message: string;
+    }) => Promise<void> | void;
+  };
+};
+type ChatChannelThreadingReplyModeOptions<TResolvedAccount> = {
+  topLevelReplyToMode: string;
+} | {
+  scopedAccountReplyToMode: {
+    resolveAccount: (cfg: DaoCoreConfig, accountId?: string | null) => TResolvedAccount;
+    resolveReplyToMode: (account: TResolvedAccount, chatType?: string | null) => ReplyToMode | null | undefined;
+    fallback?: ReplyToMode;
+  };
+} | {
+  resolveReplyToMode: NonNullable<ChannelThreadingAdapter["resolveReplyToMode"]>;
+};
+type ChatChannelThreadingOptions<TResolvedAccount> = ChatChannelThreadingReplyModeOptions<TResolvedAccount> & Omit<ChannelThreadingAdapter, "resolveReplyToMode">;
+type ChatChannelAttachedOutboundOptions = {
+  base: Omit<ChannelOutboundAdapter, "sendText" | "sendMedia" | "sendPoll">;
+  attachedResults: {
+    channel: string;
+    sendText?: (ctx: Parameters<NonNullable<ChannelOutboundAdapter["sendText"]>>[0]) => MaybePromise<Omit<OutboundDeliveryResult, "channel">>;
+    sendMedia?: (ctx: Parameters<NonNullable<ChannelOutboundAdapter["sendMedia"]>>[0]) => MaybePromise<Omit<OutboundDeliveryResult, "channel">>;
+    sendPoll?: (ctx: Parameters<NonNullable<ChannelOutboundAdapter["sendPoll"]>>[0]) => MaybePromise<Omit<ChannelPollResult, "channel">>;
+  };
+};
+type MaybePromise<T> = T | Promise<T>;
+declare function createChatChannelPlugin<TResolvedAccount extends {
+  accountId?: string | null;
+}, Probe = unknown, Audit = unknown>(params: {
+  base: ChatChannelPluginBase<TResolvedAccount, Probe, Audit>;
+  security?: ChannelSecurityAdapter<TResolvedAccount> | ChatChannelSecurityOptions<TResolvedAccount>;
+  pairing?: ChannelPairingAdapter | ChatChannelPairingOptions;
+  threading?: ChannelThreadingAdapter | ChatChannelThreadingOptions<TResolvedAccount>;
+  outbound?: ChannelOutboundAdapter | ChatChannelAttachedOutboundOptions;
+}): ChannelPlugin<TResolvedAccount, Probe, Audit>;
+declare function createChannelPluginBase<TResolvedAccount>(params: CreateChannelPluginBaseOptions<TResolvedAccount>): CreatedChannelPluginBase<TResolvedAccount>;
+//#endregion
+export { resolveTailnetHostWithRunner as _, buildThreadAwareOutboundSessionRoute as a, defineChannelPluginEntry as c, getChatChannelMeta as d, recoverCurrentThreadSessionId as f, TailscaleStatusCommandRunner as g, TailscaleStatusCommandResult as h, buildChannelOutboundSessionRoute as i, defineSetupPluginEntry as l, stripTargetKindPrefix as m, ThreadAwareOutboundSessionRouteRecoveryContext as n, createChannelPluginBase as o, stripChannelTargetPrefix as p, ThreadAwareOutboundSessionRouteThreadSource as r, createChatChannelPlugin as s, ChannelOutboundSessionRouteParams as t, ensureConfiguredAcpBindingReady as u, GatewayBindUrlResult as v, resolveGatewayBindUrl as y };

package/dist/core-api-BKlJUtDt.js

@@ -0,0 +1,5 @@
+import "./sdk-security-runtime-D1Z-V8Bd.js";
+import "./config-DlNgjF8W.js";
+import "./sdk-setup-tools-Do3DkQi_.js";
+import "./browser-runtime-KmCT6FuL.js";
+export {};

package/dist/core-api-_fiftUHn.js

@@ -0,0 +1,2 @@
+import "./core-api-BKlJUtDt.js";
+export {};

package/dist/crestodian/crestodian.js

@@ -1,2 +1,2 @@
-import { t as runCrestodian } from "../crestodian-Bp-NXiBC.js";
+import { t as runCrestodian } from "../crestodian-BJifoQiR.js";
 export { runCrestodian };

package/dist/crestodian/rescue-message.js

@@ -1,7 +1,7 @@
 import { v as resolveStateDir } from "../paths-ZwPDM6zn.js";
 import { l as normalizeAgentId } from "../session-key-Bte0mmcq.js";
 import { m as writeJson, o as tryReadJson } from "../json-files-D7wa8Ux4.js";
-import { a as parseCrestodianOperation, i as isPersistentCrestodianOperation, n as executeCrestodianOperation, r as formatCrestodianPersistentPlan } from "../operations-H3vUh0lM.js";
+import { a as parseCrestodianOperation, i as isPersistentCrestodianOperation, n as executeCrestodianOperation, r as formatCrestodianPersistentPlan } from "../operations-DT4bsxV6.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";

package/dist/crestodian-BJifoQiR.js

@@ -0,0 +1,55 @@
+import { n as defaultRuntime, r as writeRuntimeJson } from "./runtime-E_A14BX_.js";
+import { r as withProgress } from "./progress-CE2g1zbv.js";
+import { i as isPersistentCrestodianOperation, n as executeCrestodianOperation } from "./operations-DT4bsxV6.js";
+import { r as loadCrestodianOverview, t as formatCrestodianOverview } from "./overview-D2tJdx4_.js";
+import { r as resolveCrestodianOperation } from "./dialogue-BXayGhnz.js";
+import { stdin, stdout } from "node:process";
+//#region src/crestodian/crestodian.ts
+function crestodianCommandDepsFromOptions(opts) {
+	if (!opts.deps && !opts.formatOverview && !opts.loadOverview) return;
+	return {
+		...opts.deps,
+		...opts.formatOverview ? { formatOverview: opts.formatOverview } : {},
+		...opts.loadOverview ? { loadOverview: opts.loadOverview } : {}
+	};
+}
+async function runOneShot(input, runtime, opts) {
+	const operation = await resolveCrestodianOperation(input, runtime, opts);
+	await executeCrestodianOperation(operation, runtime, {
+		approved: opts.yes === true || !isPersistentCrestodianOperation(operation),
+		deps: crestodianCommandDepsFromOptions(opts)
+	});
+}
+async function runCrestodian(opts = {}, runtime = defaultRuntime) {
+	if (opts.json) {
+		writeRuntimeJson(runtime, await (opts.loadOverview ?? loadCrestodianOverview)());
+		return;
+	}
+	if (opts.message?.trim()) {
+		const overview = await withProgress({
+			label: "Loading Crestodian overview…",
+			indeterminate: true,
+			delayMs: 0,
+			fallback: "none"
+		}, async () => await (opts.loadOverview ?? loadCrestodianOverview)());
+		runtime.log((opts.formatOverview ?? formatCrestodianOverview)(overview));
+		runtime.log("");
+		await runOneShot(opts.message, runtime, opts);
+		return;
+	}
+	const interactive = opts.interactive ?? true;
+	const input = opts.input ?? stdin;
+	const output = opts.output ?? stdout;
+	const inputIsTty = input.isTTY === true;
+	const outputIsTty = output.isTTY === true;
+	if (!interactive || !inputIsTty || !outputIsTty) {
+		runtime.error("Crestodian needs an interactive TTY. Use --message for one command.");
+		runtime.exit(1);
+		return;
+	}
+	const runInteractiveTui = opts.runInteractiveTui ?? (await import("./tui-backend-fzoeoSN0.js")).runCrestodianTui;
+	opts.onReady?.();
+	await runInteractiveTui(opts, runtime);
+}
+//#endregion
+export { runCrestodian as t };

package/dist/daocore-runtime-DMcB2cnr.d.ts

@@ -0,0 +1,151 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { l as SecretInput } from "./types.secrets-tbFW-hY6.js";
+import { zi as MemoryEmbeddingProviderAdapter } from "./types-iT2EyaH92.js";
+import { n as MemoryMultimodalSettings } from "./multimodal-Dq8Bb48g.js";
+import { DatabaseSync } from "node:sqlite";
+
+//#region src/agents/pi-settings.d.ts
+declare const DEFAULT_PI_COMPACTION_RESERVE_TOKENS_FLOOR = 20000;
+//#endregion
+//#region src/agents/memory-search.d.ts
+type ResolvedMemorySearchConfig = {
+  enabled: boolean;
+  sources: Array<"memory" | "sessions">;
+  extraPaths: string[];
+  multimodal: MemoryMultimodalSettings;
+  provider: string;
+  remote?: {
+    baseUrl?: string;
+    apiKey?: SecretInput;
+    headers?: Record<string, string>;
+    nonBatchConcurrency?: number;
+    batch?: {
+      enabled: boolean;
+      wait: boolean;
+      concurrency: number;
+      pollIntervalMs: number;
+      timeoutMinutes: number;
+    };
+  };
+  experimental: {
+    sessionMemory: boolean;
+  };
+  fallback: string;
+  model: string;
+  inputType?: string;
+  queryInputType?: string;
+  documentInputType?: string;
+  outputDimensionality?: number;
+  local: {
+    modelPath?: string;
+    modelCacheDir?: string;
+    contextSize?: number | "auto";
+  };
+  store: {
+    driver: "sqlite";
+    path: string;
+    fts: {
+      tokenizer: "unicode61" | "trigram";
+    };
+    vector: {
+      enabled: boolean;
+      extensionPath?: string;
+    };
+  };
+  chunking: {
+    tokens: number;
+    overlap: number;
+  };
+  sync: {
+    onSessionStart: boolean;
+    onSearch: boolean;
+    watch: boolean;
+    watchDebounceMs: number;
+    intervalMinutes: number;
+    embeddingBatchTimeoutSeconds: number | undefined;
+    sessions: {
+      deltaBytes: number;
+      deltaMessages: number;
+      postCompactionForce: boolean;
+    };
+  };
+  query: {
+    maxResults: number;
+    minScore: number;
+    hybrid: {
+      enabled: boolean;
+      vectorWeight: number;
+      textWeight: number;
+      candidateMultiplier: number;
+      mmr: {
+        enabled: boolean;
+        lambda: number;
+      };
+      temporalDecay: {
+        enabled: boolean;
+        halfLifeDays: number;
+      };
+    };
+  };
+  cache: {
+    enabled: boolean;
+    maxEntries?: number;
+  };
+};
+type ResolvedMemorySearchSyncConfig = ResolvedMemorySearchConfig["sync"];
+declare function resolveMemorySearchConfig(cfg: DaoCoreConfig, agentId: string): ResolvedMemorySearchConfig | null;
+declare function resolveMemorySearchSyncConfig(cfg: DaoCoreConfig, agentId: string): ResolvedMemorySearchSyncConfig | null;
+//#endregion
+//#region src/cli/progress.d.ts
+type ProgressOptions = {
+  label: string;
+  indeterminate?: boolean;
+  total?: number;
+  enabled?: boolean;
+  delayMs?: number;
+  stream?: NodeJS.WriteStream;
+  fallback?: "spinner" | "line" | "log" | "none";
+};
+type ProgressReporter = {
+  setLabel: (label: string) => void;
+  setPercent: (percent: number) => void;
+  tick: (delta?: number) => void;
+  done: () => void;
+};
+type ProgressTotalsUpdate = {
+  completed: number;
+  total: number;
+  label?: string;
+};
+declare function withProgress<T>(options: ProgressOptions, work: (progress: ProgressReporter) => Promise<T>): Promise<T>;
+declare function withProgressTotals<T>(options: ProgressOptions, work: (update: (update: ProgressTotalsUpdate) => void, progress: ProgressReporter) => Promise<T>): Promise<T>;
+//#endregion
+//#region src/config/byte-size.d.ts
+/**
+ * Parse an optional byte-size value from config.
+ * Accepts non-negative numbers or strings like "2mb".
+ */
+declare function parseNonNegativeByteSize(value: unknown): number | null;
+//#endregion
+//#region src/infra/sqlite-wal.d.ts
+type SqliteWalCheckpointMode = "PASSIVE" | "FULL" | "RESTART" | "TRUNCATE";
+type SqliteWalMaintenance = {
+  checkpoint: () => boolean;
+  close: () => boolean;
+};
+type SqliteWalMaintenanceOptions = {
+  autoCheckpointPages?: number;
+  checkpointIntervalMs?: number;
+  checkpointMode?: SqliteWalCheckpointMode;
+  onCheckpointError?: (error: unknown) => void;
+};
+//#endregion
+//#region src/plugins/memory-embedding-provider-runtime.d.ts
+declare function listRegisteredMemoryEmbeddingProviderAdapters(): MemoryEmbeddingProviderAdapter[];
+declare function listMemoryEmbeddingProviders(cfg?: DaoCoreConfig): MemoryEmbeddingProviderAdapter[];
+declare function getMemoryEmbeddingProvider(id: string, cfg?: DaoCoreConfig): MemoryEmbeddingProviderAdapter | undefined;
+//#endregion
+//#region src/utils/shell-argv.d.ts
+declare function splitShellArgs(raw: string): string[] | null;
+//#endregion
+export { SqliteWalMaintenance as a, withProgress as c, ResolvedMemorySearchSyncConfig as d, resolveMemorySearchConfig as f, listRegisteredMemoryEmbeddingProviderAdapters as i, withProgressTotals as l, DEFAULT_PI_COMPACTION_RESERVE_TOKENS_FLOOR as m, getMemoryEmbeddingProvider as n, SqliteWalMaintenanceOptions as o, resolveMemorySearchSyncConfig as p, listMemoryEmbeddingProviders as r, parseNonNegativeByteSize as s, splitShellArgs as t, ResolvedMemorySearchConfig as u };