skykoi 2026.3.21 → 2026.3.23

package/dist/plugin-sdk/imessage/monitor/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeEnv } from "../../runtime.js";
+import type { MonitorIMessageOpts } from "./types.js";
+export declare function resolveRuntime(opts: MonitorIMessageOpts): RuntimeEnv;
+export declare function normalizeAllowList(list?: Array<string | number>): string[];

package/dist/plugin-sdk/imessage/monitor/types.d.ts

@@ -0,0 +1,37 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { RuntimeEnv } from "../../runtime.js";
+export type IMessageAttachment = {
+    original_path?: string | null;
+    mime_type?: string | null;
+    missing?: boolean | null;
+};
+export type IMessagePayload = {
+    id?: number | null;
+    chat_id?: number | null;
+    sender?: string | null;
+    is_from_me?: boolean | null;
+    text?: string | null;
+    reply_to_id?: number | string | null;
+    reply_to_text?: string | null;
+    reply_to_sender?: string | null;
+    created_at?: string | null;
+    attachments?: IMessageAttachment[] | null;
+    chat_identifier?: string | null;
+    chat_guid?: string | null;
+    chat_name?: string | null;
+    participants?: string[] | null;
+    is_group?: boolean | null;
+};
+export type MonitorIMessageOpts = {
+    runtime?: RuntimeEnv;
+    abortSignal?: AbortSignal;
+    cliPath?: string;
+    dbPath?: string;
+    accountId?: string;
+    config?: SKYKOIConfig;
+    allowFrom?: Array<string | number>;
+    groupAllowFrom?: Array<string | number>;
+    includeAttachments?: boolean;
+    mediaMaxMb?: number;
+    requireMention?: boolean;
+};

package/dist/plugin-sdk/imessage/monitor.d.ts

@@ -0,0 +1,2 @@
+export { monitorIMessageProvider } from "./monitor/monitor-provider.js";
+export type { MonitorIMessageOpts } from "./monitor/types.js";

package/dist/plugin-sdk/imessage/probe.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeEnv } from "../runtime.js";
+export { DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS } from "./constants.js";
+export type IMessageProbe = {
+    ok: boolean;
+    error?: string | null;
+    fatal?: boolean;
+};
+export type IMessageProbeOptions = {
+    cliPath?: string;
+    dbPath?: string;
+    runtime?: RuntimeEnv;
+};
+/**
+ * Probe iMessage RPC availability.
+ * @param timeoutMs - Explicit timeout in ms. If undefined, uses config or default.
+ * @param opts - Additional options (cliPath, dbPath, runtime).
+ */
+export declare function probeIMessage(timeoutMs?: number, opts?: IMessageProbeOptions): Promise<IMessageProbe>;

package/dist/plugin-sdk/imessage/send.d.ts

@@ -0,0 +1,18 @@
+import { type IMessageRpcClient } from "./client.js";
+import { type IMessageService } from "./targets.js";
+export type IMessageSendOpts = {
+    cliPath?: string;
+    dbPath?: string;
+    service?: IMessageService;
+    region?: string;
+    accountId?: string;
+    mediaUrl?: string;
+    maxBytes?: number;
+    timeoutMs?: number;
+    chatId?: number;
+    client?: IMessageRpcClient;
+};
+export type IMessageSendResult = {
+    messageId: string;
+};
+export declare function sendMessageIMessage(to: string, text: string, opts?: IMessageSendOpts): Promise<IMessageSendResult>;

package/dist/plugin-sdk/imessage/targets.d.ts

@@ -0,0 +1,39 @@
+export type IMessageService = "imessage" | "sms" | "auto";
+export type IMessageTarget = {
+    kind: "chat_id";
+    chatId: number;
+} | {
+    kind: "chat_guid";
+    chatGuid: string;
+} | {
+    kind: "chat_identifier";
+    chatIdentifier: string;
+} | {
+    kind: "handle";
+    to: string;
+    service: IMessageService;
+};
+export type IMessageAllowTarget = {
+    kind: "chat_id";
+    chatId: number;
+} | {
+    kind: "chat_guid";
+    chatGuid: string;
+} | {
+    kind: "chat_identifier";
+    chatIdentifier: string;
+} | {
+    kind: "handle";
+    handle: string;
+};
+export declare function normalizeIMessageHandle(raw: string): string;
+export declare function parseIMessageTarget(raw: string): IMessageTarget;
+export declare function parseIMessageAllowTarget(raw: string): IMessageAllowTarget;
+export declare function isAllowedIMessageSender(params: {
+    allowFrom: Array<string | number>;
+    sender: string;
+    chatId?: number | null;
+    chatGuid?: string | null;
+    chatIdentifier?: string | null;
+}): boolean;
+export declare function formatIMessageChatTarget(chatId?: number | null): string;

package/dist/plugin-sdk/index.d.ts

@@ -0,0 +1 @@
+export * from "./plugin-sdk/index";

package/dist/plugin-sdk/infra/SKYKOI-root.d.ts

@@ -0,0 +1,10 @@
+export declare function resolveSKYKOIPackageRoot(opts: {
+    cwd?: string;
+    argv1?: string;
+    moduleUrl?: string;
+}): Promise<string | null>;
+export declare function resolveSKYKOIPackageRootSync(opts: {
+    cwd?: string;
+    argv1?: string;
+    moduleUrl?: string;
+}): string | null;

package/dist/plugin-sdk/infra/agent-events.d.ts

@@ -0,0 +1,21 @@
+import type { VerboseLevel } from "../auto-reply/thinking.js";
+export type AgentEventStream = "lifecycle" | "tool" | "assistant" | "error" | (string & {});
+export type AgentEventPayload = {
+    runId: string;
+    seq: number;
+    stream: AgentEventStream;
+    ts: number;
+    data: Record<string, unknown>;
+    sessionKey?: string;
+};
+export type AgentRunContext = {
+    sessionKey?: string;
+    verboseLevel?: VerboseLevel;
+    isHeartbeat?: boolean;
+};
+export declare function registerAgentRunContext(runId: string, context: AgentRunContext): void;
+export declare function getAgentRunContext(runId: string): AgentRunContext | undefined;
+export declare function clearAgentRunContext(runId: string): void;
+export declare function resetAgentRunContextForTest(): void;
+export declare function emitAgentEvent(event: Omit<AgentEventPayload, "seq" | "ts">): void;
+export declare function onAgentEvent(listener: (evt: AgentEventPayload) => void): () => boolean;

package/dist/plugin-sdk/infra/backoff.d.ts

@@ -0,0 +1,8 @@
+export type BackoffPolicy = {
+    initialMs: number;
+    maxMs: number;
+    factor: number;
+    jitter: number;
+};
+export declare function computeBackoff(policy: BackoffPolicy, attempt: number): number;
+export declare function sleepWithAbort(ms: number, abortSignal?: AbortSignal): Promise<void>;

package/dist/plugin-sdk/infra/channel-activity.d.ts

@@ -0,0 +1,18 @@
+import type { ChannelId } from "../channels/plugins/types.js";
+export type ChannelDirection = "inbound" | "outbound";
+type ActivityEntry = {
+    inboundAt: number | null;
+    outboundAt: number | null;
+};
+export declare function recordChannelActivity(params: {
+    channel: ChannelId;
+    accountId?: string | null;
+    direction: ChannelDirection;
+    at?: number;
+}): void;
+export declare function getChannelActivity(params: {
+    channel: ChannelId;
+    accountId?: string | null;
+}): ActivityEntry;
+export declare function resetChannelActivityForTest(): void;
+export {};

package/dist/plugin-sdk/infra/channel-summary.d.ts

@@ -0,0 +1,7 @@
+import { type SKYKOIConfig } from "../config/config.js";
+export type ChannelSummaryOptions = {
+    colorize?: boolean;
+    includeAllowFrom?: boolean;
+};
+export declare function buildChannelSummary(cfg?: SKYKOIConfig, options?: ChannelSummaryOptions): Promise<string[]>;
+export declare function formatAge(ms: number): string;

package/dist/plugin-sdk/infra/dedupe.d.ts

@@ -0,0 +1,11 @@
+export type DedupeCache = {
+    check: (key: string | undefined | null, now?: number) => boolean;
+    clear: () => void;
+    size: () => number;
+};
+type DedupeCacheOptions = {
+    ttlMs: number;
+    maxSize: number;
+};
+export declare function createDedupeCache(options: DedupeCacheOptions): DedupeCache;
+export {};

package/dist/plugin-sdk/infra/device-auth-store.d.ts

@@ -0,0 +1,23 @@
+export type DeviceAuthEntry = {
+    token: string;
+    role: string;
+    scopes: string[];
+    updatedAtMs: number;
+};
+export declare function loadDeviceAuthToken(params: {
+    deviceId: string;
+    role: string;
+    env?: NodeJS.ProcessEnv;
+}): DeviceAuthEntry | null;
+export declare function storeDeviceAuthToken(params: {
+    deviceId: string;
+    role: string;
+    token: string;
+    scopes?: string[];
+    env?: NodeJS.ProcessEnv;
+}): DeviceAuthEntry;
+export declare function clearDeviceAuthToken(params: {
+    deviceId: string;
+    role: string;
+    env?: NodeJS.ProcessEnv;
+}): void;

package/dist/plugin-sdk/infra/device-identity.d.ts

@@ -0,0 +1,11 @@
+export type DeviceIdentity = {
+    deviceId: string;
+    publicKeyPem: string;
+    privateKeyPem: string;
+};
+export declare function loadOrCreateDeviceIdentity(filePath?: string): DeviceIdentity;
+export declare function signDevicePayload(privateKeyPem: string, payload: string): string;
+export declare function normalizeDevicePublicKeyBase64Url(publicKey: string): string | null;
+export declare function deriveDeviceIdFromPublicKey(publicKey: string): string | null;
+export declare function publicKeyRawBase64UrlFromPem(publicKeyPem: string): string;
+export declare function verifyDeviceSignature(publicKey: string, payload: string, signatureBase64Url: string): boolean;

package/dist/plugin-sdk/infra/diagnostic-events.d.ts

@@ -0,0 +1,121 @@
+import type { SKYKOIConfig } from "../config/config.js";
+export type DiagnosticSessionState = "idle" | "processing" | "waiting";
+type DiagnosticBaseEvent = {
+    ts: number;
+    seq: number;
+};
+export type DiagnosticUsageEvent = DiagnosticBaseEvent & {
+    type: "model.usage";
+    sessionKey?: string;
+    sessionId?: string;
+    channel?: string;
+    provider?: string;
+    model?: string;
+    usage: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        promptTokens?: number;
+        total?: number;
+    };
+    context?: {
+        limit?: number;
+        used?: number;
+    };
+    costUsd?: number;
+    durationMs?: number;
+};
+export type DiagnosticWebhookReceivedEvent = DiagnosticBaseEvent & {
+    type: "webhook.received";
+    channel: string;
+    updateType?: string;
+    chatId?: number | string;
+};
+export type DiagnosticWebhookProcessedEvent = DiagnosticBaseEvent & {
+    type: "webhook.processed";
+    channel: string;
+    updateType?: string;
+    chatId?: number | string;
+    durationMs?: number;
+};
+export type DiagnosticWebhookErrorEvent = DiagnosticBaseEvent & {
+    type: "webhook.error";
+    channel: string;
+    updateType?: string;
+    chatId?: number | string;
+    error: string;
+};
+export type DiagnosticMessageQueuedEvent = DiagnosticBaseEvent & {
+    type: "message.queued";
+    sessionKey?: string;
+    sessionId?: string;
+    channel?: string;
+    source: string;
+    queueDepth?: number;
+};
+export type DiagnosticMessageProcessedEvent = DiagnosticBaseEvent & {
+    type: "message.processed";
+    channel: string;
+    messageId?: number | string;
+    chatId?: number | string;
+    sessionKey?: string;
+    sessionId?: string;
+    durationMs?: number;
+    outcome: "completed" | "skipped" | "error";
+    reason?: string;
+    error?: string;
+};
+export type DiagnosticSessionStateEvent = DiagnosticBaseEvent & {
+    type: "session.state";
+    sessionKey?: string;
+    sessionId?: string;
+    prevState?: DiagnosticSessionState;
+    state: DiagnosticSessionState;
+    reason?: string;
+    queueDepth?: number;
+};
+export type DiagnosticSessionStuckEvent = DiagnosticBaseEvent & {
+    type: "session.stuck";
+    sessionKey?: string;
+    sessionId?: string;
+    state: DiagnosticSessionState;
+    ageMs: number;
+    queueDepth?: number;
+};
+export type DiagnosticLaneEnqueueEvent = DiagnosticBaseEvent & {
+    type: "queue.lane.enqueue";
+    lane: string;
+    queueSize: number;
+};
+export type DiagnosticLaneDequeueEvent = DiagnosticBaseEvent & {
+    type: "queue.lane.dequeue";
+    lane: string;
+    queueSize: number;
+    waitMs: number;
+};
+export type DiagnosticRunAttemptEvent = DiagnosticBaseEvent & {
+    type: "run.attempt";
+    sessionKey?: string;
+    sessionId?: string;
+    runId: string;
+    attempt: number;
+};
+export type DiagnosticHeartbeatEvent = DiagnosticBaseEvent & {
+    type: "diagnostic.heartbeat";
+    webhooks: {
+        received: number;
+        processed: number;
+        errors: number;
+    };
+    active: number;
+    waiting: number;
+    queued: number;
+};
+export type DiagnosticEventPayload = DiagnosticUsageEvent | DiagnosticWebhookReceivedEvent | DiagnosticWebhookProcessedEvent | DiagnosticWebhookErrorEvent | DiagnosticMessageQueuedEvent | DiagnosticMessageProcessedEvent | DiagnosticSessionStateEvent | DiagnosticSessionStuckEvent | DiagnosticLaneEnqueueEvent | DiagnosticLaneDequeueEvent | DiagnosticRunAttemptEvent | DiagnosticHeartbeatEvent;
+export type DiagnosticEventInput = DiagnosticEventPayload extends infer Event ? Event extends DiagnosticEventPayload ? Omit<Event, "seq" | "ts"> : never : never;
+export declare function isDiagnosticsEnabled(config?: SKYKOIConfig): boolean;
+export declare function emitDiagnosticEvent(event: DiagnosticEventInput): void;
+export declare function onDiagnosticEvent(listener: (evt: DiagnosticEventPayload) => void): () => void;
+export declare function resetDiagnosticEventsForTest(): void;
+export {};

package/dist/plugin-sdk/infra/diagnostic-flags.d.ts

@@ -0,0 +1,4 @@
+import type { SKYKOIConfig } from "../config/config.js";
+export declare function resolveDiagnosticFlags(cfg?: SKYKOIConfig, env?: NodeJS.ProcessEnv): string[];
+export declare function matchesDiagnosticFlag(flag: string, enabledFlags: string[]): boolean;
+export declare function isDiagnosticFlagEnabled(flag: string, cfg?: SKYKOIConfig, env?: NodeJS.ProcessEnv): boolean;

package/dist/plugin-sdk/infra/env.d.ts

@@ -0,0 +1,11 @@
+type AcceptedEnvOption = {
+    key: string;
+    description: string;
+    value?: string;
+    redact?: boolean;
+};
+export declare function logAcceptedEnvOption(option: AcceptedEnvOption): void;
+export declare function normalizeZaiEnv(): void;
+export declare function isTruthyEnvValue(value?: string): boolean;
+export declare function normalizeEnv(): void;
+export {};

package/dist/plugin-sdk/infra/errors.d.ts

@@ -0,0 +1,3 @@
+export declare function extractErrorCode(err: unknown): string | undefined;
+export declare function formatErrorMessage(err: unknown): string;
+export declare function formatUncaughtError(err: unknown): string;

package/dist/plugin-sdk/infra/exec-approvals.d.ts

@@ -0,0 +1,155 @@
+export type ExecHost = "sandbox" | "gateway" | "node";
+export type ExecSecurity = "deny" | "allowlist" | "full";
+export type ExecAsk = "off" | "on-miss" | "always";
+export type ExecApprovalsDefaults = {
+    security?: ExecSecurity;
+    ask?: ExecAsk;
+    askFallback?: ExecSecurity;
+    autoAllowSkills?: boolean;
+};
+export type ExecAllowlistEntry = {
+    id?: string;
+    pattern: string;
+    lastUsedAt?: number;
+    lastUsedCommand?: string;
+    lastResolvedPath?: string;
+};
+export type ExecApprovalsAgent = ExecApprovalsDefaults & {
+    allowlist?: ExecAllowlistEntry[];
+};
+export type ExecApprovalsFile = {
+    version: 1;
+    socket?: {
+        path?: string;
+        token?: string;
+    };
+    defaults?: ExecApprovalsDefaults;
+    agents?: Record<string, ExecApprovalsAgent>;
+};
+export type ExecApprovalsSnapshot = {
+    path: string;
+    exists: boolean;
+    raw: string | null;
+    file: ExecApprovalsFile;
+    hash: string;
+};
+export type ExecApprovalsResolved = {
+    path: string;
+    socketPath: string;
+    token: string;
+    defaults: Required<ExecApprovalsDefaults>;
+    agent: Required<ExecApprovalsDefaults>;
+    allowlist: ExecAllowlistEntry[];
+    file: ExecApprovalsFile;
+};
+export declare const DEFAULT_SAFE_BINS: string[];
+export declare function resolveExecApprovalsPath(): string;
+export declare function resolveExecApprovalsSocketPath(): string;
+export declare function normalizeExecApprovals(file: ExecApprovalsFile): ExecApprovalsFile;
+export declare function readExecApprovalsSnapshot(): ExecApprovalsSnapshot;
+export declare function loadExecApprovals(): ExecApprovalsFile;
+export declare function saveExecApprovals(file: ExecApprovalsFile): void;
+export declare function ensureExecApprovals(): ExecApprovalsFile;
+export type ExecApprovalsDefaultOverrides = {
+    security?: ExecSecurity;
+    ask?: ExecAsk;
+    askFallback?: ExecSecurity;
+    autoAllowSkills?: boolean;
+};
+export declare function resolveExecApprovals(agentId?: string, overrides?: ExecApprovalsDefaultOverrides): ExecApprovalsResolved;
+export declare function resolveExecApprovalsFromFile(params: {
+    file: ExecApprovalsFile;
+    agentId?: string;
+    overrides?: ExecApprovalsDefaultOverrides;
+    path?: string;
+    socketPath?: string;
+    token?: string;
+}): ExecApprovalsResolved;
+type CommandResolution = {
+    rawExecutable: string;
+    resolvedPath?: string;
+    executableName: string;
+};
+export declare function resolveCommandResolution(command: string, cwd?: string, env?: NodeJS.ProcessEnv): CommandResolution | null;
+export declare function resolveCommandResolutionFromArgv(argv: string[], cwd?: string, env?: NodeJS.ProcessEnv): CommandResolution | null;
+export declare function matchAllowlist(entries: ExecAllowlistEntry[], resolution: CommandResolution | null): ExecAllowlistEntry | null;
+export type ExecCommandSegment = {
+    raw: string;
+    argv: string[];
+    resolution: CommandResolution | null;
+};
+export type ExecCommandAnalysis = {
+    ok: boolean;
+    reason?: string;
+    segments: ExecCommandSegment[];
+    chains?: ExecCommandSegment[][];
+};
+export declare function analyzeShellCommand(params: {
+    command: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    platform?: string | null;
+}): ExecCommandAnalysis;
+export declare function analyzeArgvCommand(params: {
+    argv: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): ExecCommandAnalysis;
+export declare function normalizeSafeBins(entries?: string[]): Set<string>;
+export declare function resolveSafeBins(entries?: string[] | null): Set<string>;
+export declare function isSafeBinUsage(params: {
+    argv: string[];
+    resolution: CommandResolution | null;
+    safeBins: Set<string>;
+    cwd?: string;
+    fileExists?: (filePath: string) => boolean;
+}): boolean;
+export type ExecAllowlistEvaluation = {
+    allowlistSatisfied: boolean;
+    allowlistMatches: ExecAllowlistEntry[];
+};
+export declare function evaluateExecAllowlist(params: {
+    analysis: ExecCommandAnalysis;
+    allowlist: ExecAllowlistEntry[];
+    safeBins: Set<string>;
+    cwd?: string;
+    skillBins?: Set<string>;
+    autoAllowSkills?: boolean;
+}): ExecAllowlistEvaluation;
+export type ExecAllowlistAnalysis = {
+    analysisOk: boolean;
+    allowlistSatisfied: boolean;
+    allowlistMatches: ExecAllowlistEntry[];
+    segments: ExecCommandSegment[];
+};
+/**
+ * Evaluates allowlist for shell commands (including &&, ||, ;) and returns analysis metadata.
+ */
+export declare function evaluateShellAllowlist(params: {
+    command: string;
+    allowlist: ExecAllowlistEntry[];
+    safeBins: Set<string>;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    skillBins?: Set<string>;
+    autoAllowSkills?: boolean;
+    platform?: string | null;
+}): ExecAllowlistAnalysis;
+export declare function requiresExecApproval(params: {
+    ask: ExecAsk;
+    security: ExecSecurity;
+    analysisOk: boolean;
+    allowlistSatisfied: boolean;
+}): boolean;
+export declare function recordAllowlistUse(approvals: ExecApprovalsFile, agentId: string | undefined, entry: ExecAllowlistEntry, command: string, resolvedPath?: string): void;
+export declare function addAllowlistEntry(approvals: ExecApprovalsFile, agentId: string | undefined, pattern: string): void;
+export declare function minSecurity(a: ExecSecurity, b: ExecSecurity): ExecSecurity;
+export declare function maxAsk(a: ExecAsk, b: ExecAsk): ExecAsk;
+export type ExecApprovalDecision = "allow-once" | "allow-always" | "deny";
+export declare function requestExecApprovalViaSocket(params: {
+    socketPath: string;
+    token: string;
+    request: Record<string, unknown>;
+    timeoutMs?: number;
+}): Promise<ExecApprovalDecision | null>;
+export {};

package/dist/plugin-sdk/infra/exec-safety.d.ts

@@ -0,0 +1 @@
+export declare function isSafeExecutableValue(value: string | null | undefined): boolean;

package/dist/plugin-sdk/infra/fetch.d.ts

@@ -0,0 +1,2 @@
+export declare function wrapFetchWithAbortSignal(fetchImpl: typeof fetch): typeof fetch;
+export declare function resolveFetch(fetchImpl?: typeof fetch): typeof fetch | undefined;

package/dist/plugin-sdk/infra/format-duration.d.ts

@@ -0,0 +1,10 @@
+export type FormatDurationSecondsOptions = {
+    decimals?: number;
+    unit?: "s" | "seconds";
+};
+export declare function formatDurationSeconds(ms: number, options?: FormatDurationSecondsOptions): string;
+export type FormatDurationMsOptions = {
+    decimals?: number;
+    unit?: "s" | "seconds";
+};
+export declare function formatDurationMs(ms: number, options?: FormatDurationMsOptions): string;

package/dist/plugin-sdk/infra/git-commit.d.ts

@@ -0,0 +1,4 @@
+export declare const resolveCommitHash: (options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}) => string | null;

package/dist/plugin-sdk/infra/heartbeat-events.d.ts

@@ -0,0 +1,21 @@
+export type HeartbeatIndicatorType = "ok" | "alert" | "error";
+export type HeartbeatEventPayload = {
+    ts: number;
+    status: "sent" | "ok-empty" | "ok-token" | "skipped" | "failed";
+    to?: string;
+    accountId?: string;
+    preview?: string;
+    durationMs?: number;
+    hasMedia?: boolean;
+    reason?: string;
+    /** The channel this heartbeat was sent to. */
+    channel?: string;
+    /** Whether the message was silently suppressed (showOk: false). */
+    silent?: boolean;
+    /** Indicator type for UI status display. */
+    indicatorType?: HeartbeatIndicatorType;
+};
+export declare function resolveIndicatorType(status: HeartbeatEventPayload["status"]): HeartbeatIndicatorType | undefined;
+export declare function emitHeartbeatEvent(evt: Omit<HeartbeatEventPayload, "ts">): void;
+export declare function onHeartbeatEvent(listener: (evt: HeartbeatEventPayload) => void): () => void;
+export declare function getLastHeartbeatEvent(): HeartbeatEventPayload | null;

package/dist/plugin-sdk/infra/heartbeat-runner.d.ts

@@ -0,0 +1,44 @@
+import type { ChannelHeartbeatDeps } from "../channels/plugins/types.js";
+import type { SKYKOIConfig } from "../config/config.js";
+import type { AgentDefaultsConfig } from "../config/types.agent-defaults.js";
+import type { OutboundSendDeps } from "./outbound/deliver.js";
+import { type RuntimeEnv } from "../runtime.js";
+import { type HeartbeatRunResult } from "./heartbeat-wake.js";
+type HeartbeatDeps = OutboundSendDeps & ChannelHeartbeatDeps & {
+    runtime?: RuntimeEnv;
+    getQueueSize?: (lane?: string) => number;
+    nowMs?: () => number;
+};
+export declare function setHeartbeatsEnabled(enabled: boolean): void;
+type HeartbeatConfig = AgentDefaultsConfig["heartbeat"];
+export type HeartbeatSummary = {
+    enabled: boolean;
+    every: string;
+    everyMs: number | null;
+    prompt: string;
+    target: string;
+    model?: string;
+    ackMaxChars: number;
+};
+export type HeartbeatRunner = {
+    stop: () => void;
+    updateConfig: (cfg: SKYKOIConfig) => void;
+};
+export declare function isHeartbeatEnabledForAgent(cfg: SKYKOIConfig, agentId?: string): boolean;
+export declare function resolveHeartbeatSummaryForAgent(cfg: SKYKOIConfig, agentId?: string): HeartbeatSummary;
+export declare function resolveHeartbeatIntervalMs(cfg: SKYKOIConfig, overrideEvery?: string, heartbeat?: HeartbeatConfig): number | null;
+export declare function resolveHeartbeatPrompt(cfg: SKYKOIConfig, heartbeat?: HeartbeatConfig): string;
+export declare function runHeartbeatOnce(opts: {
+    cfg?: SKYKOIConfig;
+    agentId?: string;
+    heartbeat?: HeartbeatConfig;
+    reason?: string;
+    deps?: HeartbeatDeps;
+}): Promise<HeartbeatRunResult>;
+export declare function startHeartbeatRunner(opts: {
+    cfg?: SKYKOIConfig;
+    runtime?: RuntimeEnv;
+    abortSignal?: AbortSignal;
+    runOnce?: typeof runHeartbeatOnce;
+}): HeartbeatRunner;
+export {};

package/dist/plugin-sdk/infra/heartbeat-visibility.d.ts

@@ -0,0 +1,17 @@
+import type { SKYKOIConfig } from "../config/config.js";
+import type { GatewayMessageChannel } from "../utils/message-channel.js";
+export type ResolvedHeartbeatVisibility = {
+    showOk: boolean;
+    showAlerts: boolean;
+    useIndicator: boolean;
+};
+/**
+ * Resolve heartbeat visibility settings for a channel.
+ * Supports both deliverable channels (telegram, signal, etc.) and webchat.
+ * For webchat, uses channels.defaults.heartbeat since webchat doesn't have per-channel config.
+ */
+export declare function resolveHeartbeatVisibility(params: {
+    cfg: SKYKOIConfig;
+    channel: GatewayMessageChannel;
+    accountId?: string;
+}): ResolvedHeartbeatVisibility;