@cline/core 0.0.85 → 0.0.86-nightly.1790389788

package/dist/cloud/repositories.d.ts

@@ -0,0 +1,21 @@
+export type CloudRepositoryOption = {
+    id: number;
+    name: string;
+    fullName: string;
+    url: string;
+    defaultBranch: string;
+};
+export type CloudRepositoryListResult = {
+    connected: boolean;
+    connectUrl: string;
+    repositories: CloudRepositoryOption[];
+};
+export type CloudBranchListResult = {
+    available: boolean;
+    branches: string[];
+    nextToken?: string;
+};
+export type CloudBranchListOptions = {
+    cursor?: string;
+    query?: string;
+};

package/dist/cloud/snapshots.d.ts

@@ -0,0 +1,22 @@
+import type { HubEventEnvelope } from "@cline/shared";
+import type { JsonRecord, CloudQueuedPrompt as PromptInQueue } from "./types";
+export declare function readSessionRows(payload: Record<string, unknown> | undefined): JsonRecord[];
+export declare function updatedAt(record: JsonRecord): number;
+export declare function sessionRowModelId(record: JsonRecord | undefined): string;
+export declare function isRootSessionRow(record: JsonRecord): boolean;
+export declare function countPromptOccurrences(messages: unknown[], prompts: PromptInQueue[], prompt: string): number;
+export declare function submittedPromptsFromEvents(events: HubEventEnvelope[]): PromptInQueue[];
+/** Reconciles each completed run separately; tools dedupe by stable call id. */
+export declare function reconcileBufferedCloudEvents(events: HubEventEnvelope[], snapshotMessages: unknown[], options?: {
+    /**
+     * Whether a fresh queue snapshot was fetched and applied during
+     * rehydration. When it was, queue events received before its reply are
+     * stale; later events still win. When the fetch failed, the newest
+     * buffered queue event is the best state available.
+     */
+    queueSnapshotApplied?: boolean;
+    queueSnapshotEventCutoff?: number;
+    /** Events received after the transcript reply cannot be reflected in it. */
+    messagesSnapshotEventCutoff?: number;
+    baselineMessages?: unknown[];
+}): HubEventEnvelope[];

package/dist/cloud/state.d.ts

@@ -0,0 +1,13 @@
+import { type HubEventEnvelope } from "@cline/shared";
+import type { CloudSessionState } from "./types";
+export declare function immutableCopy<T>(value: T): T;
+export declare function normalizeSessionTitle(title?: string | null): string | undefined;
+export declare function stringifyMessageContent(value: unknown): string;
+export declare function resolveSessionListTitle(options: {
+    sessionId: string;
+    metadata?: unknown;
+    prompt?: string | null;
+    messages?: unknown[];
+}): string;
+/** Mutates only controller-owned state. Hosts receive frozen copies afterwards. */
+export declare function reduceCloudEvent(state: CloudSessionState, event: HubEventEnvelope, streams: Map<string, number>, sessionId: string): void;

package/dist/cloud/types.d.ts

@@ -0,0 +1,84 @@
+import type { AgentMode, HubEventEnvelope, MessageWithMetadata } from "@cline/shared";
+import type { CloudSessionRecord, CreateCloudSessionInput } from "./api";
+export type JsonRecord = Record<string, unknown>;
+export type CloudCreationOptions = Pick<CreateCloudSessionInput, "autoApproveTools" | "thinking" | "reasoningEffort">;
+export type CloudHandoffSeed = {
+    sourceSessionId: string;
+    messages: MessageWithMetadata[];
+    mode?: AgentMode;
+    workspaceRelativePath?: string;
+    config?: CloudCreationOptions;
+    /** An earlier dispatch may still complete: only adopt a matching existing seed. */
+    recoverOnly?: boolean;
+    onSeeding?: () => void | Promise<void>;
+};
+export type CloudQueuedPrompt = {
+    id: string;
+    prompt: string;
+    steer: boolean;
+    attachmentCount?: number;
+    userImages?: string[];
+};
+export type CloudApproval = {
+    requestId: string;
+    sessionId: string;
+    approvalId: string;
+    createdAt: string;
+    toolCallId: string;
+    toolName: string;
+    input?: unknown;
+    iteration?: number;
+    agentId?: string;
+    conversationId?: string;
+};
+/** Internal mutable state; snapshots returned to hosts are deep copied and frozen. */
+export type CloudSessionState = {
+    config: JsonRecord;
+    messages: MessageWithMetadata[];
+    promptsInQueue: CloudQueuedPrompt[];
+    busy: boolean;
+    startedAt: number;
+    endedAt?: number;
+    status: string;
+    prompt?: string;
+    title?: string;
+    attachedViaHub?: boolean;
+    lastHubStatusSequence?: number;
+    lastQueuedPromptStartId?: string;
+    usage?: JsonRecord;
+};
+export type CloudConnectionState = "detached" | "connecting" | "connected" | "reconnecting";
+export type CloudSessionSnapshot = Readonly<CloudSessionState & {
+    sessionId: string;
+    record?: CloudSessionRecord;
+    approvals: CloudApproval[];
+    connectionState: CloudConnectionState;
+    transcriptKnown: boolean;
+}>;
+export type CloudSessionEvent = {
+    type: "prompt_accepted";
+    sessionId: string;
+    prompt: string;
+    delivery?: "queue" | "steer";
+} | {
+    type: "snapshot";
+    sessionId: string;
+    snapshot: CloudSessionSnapshot;
+    replace: boolean;
+    cause?: "status" | "ended" | "queue" | "approvals";
+} | {
+    type: "hub_event";
+    sessionId: string;
+    event: HubEventEnvelope;
+} | {
+    type: "sync_failed";
+    sessionId: string;
+    message: string;
+} | {
+    type: "removed";
+    sessionId: string;
+};
+export type CloudSessionAttachment = JsonRecord & {
+    sessionId: string;
+    status: string;
+};

package/dist/cron/service/schedule-tool.d.ts

@@ -6,10 +6,10 @@ export declare const ScheduledTaskInputSchema: z.ZodObject<{
         update: "update";
         create: "create";
         list: "list";
-        get: "get";
-        delete: "delete";
         pause: "pause";
         resume: "resume";
+        get: "get";
+        delete: "delete";
         run_now: "run_now";
     }>;
     schedule_id: z.ZodOptional<z.ZodString>;
@@ -24,8 +24,8 @@ export declare const ScheduledTaskInputSchema: z.ZodObject<{
     timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     mode: z.ZodOptional<z.ZodEnum<{
-        act: "act";
         plan: "plan";
+        act: "act";
         yolo: "yolo";
     }>>;
     system_prompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/hub/client/index.d.ts

@@ -4,6 +4,9 @@ type HubCommandOptions = {
     timeoutMs?: number | null;
     /** Synchronous local guard, checked after connection before each dispatch. */
     beforeDispatch?: () => void;
+    /** Observes this attempt's correlation id after the local guard, before sending.
+     * Dispatch alone does not confirm that the server accepted the command. */
+    onDispatch?: (requestId: string) => void;
 };
 export interface HubClientOptions {
     url: string;
@@ -28,6 +31,11 @@ export interface LocalHubResolutionOptions {
     strategy?: "prefer-hub" | "require-hub";
     workspaceRoot?: string;
     cwd?: string;
+    /**
+     * Called with the error when starting a detached Hub fails. The function
+     * still resolves `undefined` in that case; this lets a caller report why.
+     */
+    onStartupError?: (error: unknown) => void;
 }
 export type HubTransportErrorCode = "hub_connect_timeout" | "hub_connect_failed" | "hub_connection_closed" | "hub_connection_not_open";
 export declare class HubTransportError extends Error {

package/dist/hub/daemon/bind-diagnostics.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Best-effort description of who holds the Hub port when the daemon dies with
+ * `EADDRINUSE`. The daemon takes the owner instance lock before binding, so an
+ * occupant on the port is never a live Hub for this owner; these details tell
+ * us what it actually is (an older pre-lock Hub, a leaked handle, another
+ * owner context, or an unrelated program) so the fix can target that case.
+ */
+import type { TelemetryProperties } from "@cline/shared";
+/** `lsof -Fpc` emits `p<pid>` then `c<command>` per process. */
+export declare function parseLsofOwners(output: string): string[];
+/** Telemetry context for a `hub.daemon.startup` failure caused by `EADDRINUSE`. */
+export declare function describeAddressInUse(error: unknown, endpoint: {
+    host: string;
+    port: number;
+    pathname: string;
+}): Promise<TelemetryProperties>;