@kilocode/client 0.0.0-stage → 0.0.0-v2-9

package/dist/service.d.ts

@@ -0,0 +1,52 @@
+/** Connection details for a local OpenCode service. */
+export type Endpoint = {
+    /** Base URL of the service. */
+    readonly url: string;
+    /** Authentication required by the service, when configured. */
+    readonly auth?: {
+        /** HTTP authentication scheme. */
+        readonly type: "basic";
+        /** Basic authentication username. */
+        readonly username: string;
+        /** Basic authentication password. */
+        readonly password: string;
+    };
+};
+/** Options used to discover the local OpenCode service. */
+export type DiscoverOptions = {
+    /** Absolute registration file path. Defaults to the XDG state directory. */
+    readonly file?: string;
+    /** Required exact service version or compatibility predicate. */
+    readonly version?: string | ((version: string) => boolean);
+};
+/** Reason ensuring the service requires a new process. */
+export type EnsureReason = "missing" | "version-mismatch";
+/** Options used to ensure the local OpenCode service is running. */
+export type EnsureOptions = DiscoverOptions & {
+    /** Service command and arguments. Defaults to `opencode serve --service`. */
+    readonly command?: ReadonlyArray<string>;
+    /** Environment variables added to the inherited service process environment. */
+    readonly env?: Readonly<Record<string, string>>;
+    /** Called once before spawning a new service process. */
+    readonly onStart?: (reason: EnsureReason, previousVersion?: string) => void;
+};
+/** Options used to stop the local OpenCode service. */
+export type StopOptions = {
+    /** Absolute registration file path. Defaults to the XDG state directory. */
+    readonly file?: string;
+    /** How to handle persistent terminals before stopping the service. */
+    readonly pty?: "clear" | "handoff";
+};
+/** Contents of the local service registration file. */
+export type Info = {
+    /** Unique service instance identifier. */
+    readonly id?: string;
+    /** OpenCode version served by the process. */
+    readonly version?: string;
+    /** Base URL advertised by the service. */
+    readonly url: string;
+    /** Operating system process identifier. */
+    readonly pid: number;
+    /** Private service password, when authentication is enabled. */
+    readonly password?: string;
+};

package/dist/service.js

@@ -0,0 +1 @@
+import"./chunks/contract-qav6mfdz.js";

package/dist/shared-events.d.ts

@@ -0,0 +1,11 @@
+export * as SharedEvents from "./shared-events.js";
+export type SubscribeOptions = {
+    readonly signal?: AbortSignal;
+    /** Reports transport activity on the shared stream, including keepalive frames that carry no event. */
+    readonly onActivity?: () => void;
+};
+export declare function make<A extends {
+    readonly type: string;
+}>(connect: (signal: AbortSignal, onActivity: () => void) => AsyncIterable<A>): {
+    subscribe(options?: SubscribeOptions): AsyncIterable<A>;
+};

package/dist/shared-events.js

@@ -0,0 +1,8 @@
+import {
+  make7,
+  exports_shared_events
+} from "./chunks/contract-8bbb028w.js";
+export {
+  exports_shared_events as SharedEvents,
+  make7 as make
+};

package/dist/solid/connection.d.ts

@@ -0,0 +1,37 @@
+import type { OpenCodeClient, OpenCodeEvent } from "../promise";
+export type ClientConnectionStatus = "connected" | "connecting" | "reconnecting";
+export type ClientConnectionEvent = {
+    readonly type: "client.connection";
+    readonly created: number;
+    readonly data: {
+        readonly status: "connecting" | "connected" | "disconnected" | "reconnecting";
+        readonly attempt: number;
+        readonly error?: string;
+    };
+};
+export type ClientConnectionOptions = {
+    readonly reconnect?: (signal: AbortSignal) => Promise<OpenCodeClient>;
+    readonly onEvent: (event: OpenCodeEvent) => void;
+    readonly flushInterval?: number;
+    readonly pageLifecycle?: boolean;
+    /**
+     * Abort and reconnect a stream that receives no bytes for this long. The server writes a keepalive
+     * comment every 15 seconds, so a quiet but healthy stream never trips this.
+     */
+    readonly idleTimeout?: number;
+    readonly log?: {
+        readonly debug?: (message: string, data?: Readonly<Record<string, unknown>>) => void;
+        readonly info?: (message: string, data?: Readonly<Record<string, unknown>>) => void;
+    };
+};
+export declare const defaultIdleTimeout = 45000;
+export declare const foregroundIdleThreshold = 20000;
+export declare function createClientConnection(initialApi: OpenCodeClient, options: ClientConnectionOptions): {
+    status: () => ClientConnectionStatus;
+    attempt: () => number;
+    error: () => string | undefined;
+    internal: {
+        history: () => ClientConnectionEvent[];
+        resync: (reason: string) => void;
+    };
+};

package/dist/solid/connection.js

@@ -0,0 +1,10 @@
+import {
+  defaultIdleTimeout2,
+  foregroundIdleThreshold2,
+  createClientConnection2
+} from "../chunks/contract-ydhz1zrh.js";
+export {
+  createClientConnection2 as createClientConnection,
+  defaultIdleTimeout2 as defaultIdleTimeout,
+  foregroundIdleThreshold2 as foregroundIdleThreshold
+};

package/dist/solid/data.d.ts

@@ -0,0 +1,211 @@
+import type { AgentInfo, CommandInfo, ConfigEntry, SessionFormCancelInput, FormInfo, SessionFormReplyInput, IntegrationInfo, LocationRef, McpResource, McpServer, ModelInfo, ModelRef, PermissionSavedInfo, PermissionRequest, PermissionReplyInput, Project, ProviderInfo, ReferenceInfo, SessionMessageInfo, SessionInfo, SessionInboxInfo, SessionInboxCompaction, ShellInfo, SkillInfo, VcsInfo, OpenCodeEvent, OpenCodeClient, WebSearchProvider } from "../promise";
+import { type SessionPromptInput } from "../promise";
+export type DataSessionStatus = "idle" | "running";
+/**
+ * Where a pending user prompt stands relative to the runner: `starting` is promoted at the next idle boundary,
+ * `steering` waits for the next step boundary of an execution that already delivered input, `stranded` outlived an
+ * execution that ended without delivering it, and `queued` waits for every steer to drain.
+ */
+export type DataPendingStatus = "starting" | "steering" | "stranded" | "queued";
+type OpenCodeEventMap = {
+    [Type in OpenCodeEvent["type"]]: Extract<OpenCodeEvent, {
+        type: Type;
+    }>;
+};
+export type CreateDataInput = {
+    readonly api: () => OpenCodeClient;
+    readonly directory: string;
+    /** Raw-message window used for an initial transcript read. Older pages retain their normal size. */
+    readonly initialMessageLimit?: () => number;
+    readonly event: {
+        readonly on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: OpenCodeEventMap[Type]) => void) => () => void;
+        readonly listen: (handler: (event: {
+            name: OpenCodeEvent["type"];
+            details: OpenCodeEvent;
+        }) => void) => () => void;
+    };
+    readonly connection?: {
+        readonly status: () => "connected" | "connecting" | "reconnecting";
+    };
+    /** Receives failed event-driven reads. Explicit reads still reject to their caller. */
+    readonly onError?: (error: unknown) => void;
+};
+export declare const settleMs = 150;
+export type FormWithLocation = FormInfo & {
+    readonly location?: LocationRef;
+};
+type ShellWithLocation = ShellInfo & {
+    readonly location: LocationRef;
+};
+export declare function locationKey(location: LocationRef): string;
+export declare function createData(config: CreateDataInput): {
+    on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: OpenCodeEventMap[Type]) => void) => () => void;
+    listen: (handler: (event: {
+        name: OpenCodeEvent["type"];
+        details: OpenCodeEvent;
+    }) => void) => () => void;
+    session: {
+        list(): SessionInfo[];
+        get(sessionID: string): SessionInfo;
+        creating(sessionID: string): boolean;
+        remember(info: SessionInfo): void;
+        setStatus(sessionID: string, status: DataSessionStatus): void;
+        root(sessionID: string): string;
+        family(sessionID: string): string[];
+        /** Clear heavy cached data for the root and all known descendants. */
+        evict(sessionID: string): void;
+        cost(sessionID: string): number;
+        status(sessionID: string): DataSessionStatus;
+        active(): string[];
+        input: {
+            list(sessionID: string): string[];
+            has(sessionID: string, inboxID: string): boolean;
+        };
+        pending: {
+            list(sessionID: string): SessionInboxInfo[];
+            status(sessionID: string, inboxID: string): DataPendingStatus | undefined;
+            sync(sessionID: string): Promise<void>;
+            invalidate(sessionID: string): void;
+        };
+        create(input: {
+            id?: string;
+            title?: string;
+            agent?: string;
+            model?: ModelRef;
+            location?: LocationRef;
+            projectID?: string;
+        }): {
+            id: string;
+            request: Promise<SessionInfo>;
+        };
+        compact(input: {
+            sessionID: string;
+            model?: ModelRef;
+        }): Promise<SessionInboxCompaction>;
+        prompt(input: SessionPromptInput & {
+            gate?: Promise<unknown>;
+            prepare?: () => Promise<unknown>;
+        }): Promise<import("../promise").SessionInboxUser>;
+        sync(sessionID: string, options?: {
+            children?: boolean;
+        }): Promise<void>;
+        invalidate(sessionID: string): void;
+        message: {
+            list(sessionID: string): SessionMessageInfo[];
+            get(sessionID: string, messageID: string): SessionMessageInfo | undefined;
+            sync(sessionID: string): Promise<void>;
+            more(sessionID: string): boolean;
+            loading(sessionID: string): boolean;
+            loadMore(sessionID: string, options?: {
+                all?: boolean;
+                signal?: AbortSignal;
+                /** Runs synchronously inside the store-publication batch. */
+                beforePublish?: () => void;
+            }): Promise<void>;
+            invalidate(sessionID: string): void;
+        };
+        permission: {
+            list(sessionID: string): PermissionRequest[];
+            sessions(): string[];
+            sync(sessionID: string): Promise<void>;
+            invalidate(sessionID: string): void;
+            reply(input: PermissionReplyInput): Promise<void>;
+        };
+        form: {
+            list(sessionID: string, ref?: LocationRef): FormWithLocation[] | undefined;
+            sessions(): string[];
+            sync(sessionID: string, ref?: LocationRef): Promise<void>;
+            invalidate(sessionID: string, ref?: LocationRef): void;
+            reply(input: SessionFormReplyInput, ref?: LocationRef): Promise<void>;
+            cancel(input: SessionFormCancelInput, ref?: LocationRef): Promise<void>;
+        };
+    };
+    project: {
+        list(): Project[];
+        get(projectID: string): Project;
+        sync(): Promise<void>;
+        invalidate(): void;
+        permission: {
+            list(projectID: string): PermissionSavedInfo[];
+            sync(projectID: string): Promise<void>;
+            invalidate(projectID: string): void;
+        };
+    };
+    shell: {
+        list(location?: LocationRef): ShellWithLocation[];
+        listBySession(sessionID: string): ShellWithLocation[];
+        get(id: string): ShellWithLocation | undefined;
+        sync: (ref?: LocationRef) => Promise<void>;
+        invalidate: (ref?: LocationRef) => void;
+    };
+    location: {
+        info(ref?: LocationRef): import("../promise").LocationPublicInfo | undefined;
+        default(): LocationRef;
+        syncInfo(ref?: LocationRef): Promise<void>;
+        sync(ref?: LocationRef): Promise<void>;
+        invalidate(ref?: LocationRef): void;
+        vcs: {
+            info: (ref?: LocationRef) => VcsInfo | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        agent: {
+            list: (ref?: LocationRef) => AgentInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        command: {
+            list: (ref?: LocationRef) => CommandInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        config: {
+            list: (ref?: LocationRef) => ConfigEntry[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        integration: {
+            list: (ref?: LocationRef) => IntegrationInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        mcp: {
+            server: {
+                list: (ref?: LocationRef) => McpServer[] | undefined;
+                sync: (ref?: LocationRef) => Promise<void>;
+                invalidate: (ref?: LocationRef) => void;
+            };
+            resource: {
+                list: (ref?: LocationRef) => McpResource[] | undefined;
+                sync: (ref?: LocationRef) => Promise<void>;
+                invalidate: (ref?: LocationRef) => void;
+            };
+        };
+        model: {
+            list: (ref?: LocationRef) => ModelInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        provider: {
+            list: (ref?: LocationRef) => ProviderInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        reference: {
+            list: (ref?: LocationRef) => ReferenceInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        websearch: {
+            list(location?: LocationRef): WebSearchProvider[] | undefined;
+            refresh(ref?: LocationRef): Promise<void>;
+        };
+        skill: {
+            list: (ref?: LocationRef) => SkillInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+    };
+};
+export type Data = ReturnType<typeof createData>;
+export {};

package/dist/solid/data.js

@@ -0,0 +1,18 @@
+import {
+  settleMs2,
+  locationKey2,
+  createData2
+} from "../chunks/contract-1x65x4hv.js";
+import"../chunks/contract-m2eywc8w.js";
+import"../chunks/contract-vwtmm97t.js";
+import"../chunks/contract-vyas3vgt.js";
+import"../chunks/contract-s2hya144.js";
+import"../chunks/contract-nwcpakzx.js";
+import"../chunks/contract-skhp7hxc.js";
+import"../chunks/contract-c46qzyff.js";
+import"../chunks/contract-8bbb028w.js";
+export {
+  createData2 as createData,
+  locationKey2 as locationKey,
+  settleMs2 as settleMs
+};

package/dist/solid/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./data";
+export * from "./connection";
+export * from "./pty";
+export * from "./usage";

package/dist/solid/index.js

@@ -0,0 +1,36 @@
+import"../chunks/contract-nwcpakzx.js";
+import"../chunks/contract-s2hya144.js";
+import"../chunks/contract-c46qzyff.js";
+import"../chunks/contract-vyas3vgt.js";
+import"../chunks/contract-8bbb028w.js";
+import"../chunks/contract-skhp7hxc.js";
+import"../chunks/contract-vwtmm97t.js";
+import"../chunks/contract-m2eywc8w.js";
+import {
+  settleMs2,
+  locationKey2,
+  createData2
+} from "../chunks/contract-1x65x4hv.js";
+import {
+  defaultIdleTimeout2,
+  foregroundIdleThreshold2,
+  createClientConnection2
+} from "../chunks/contract-ydhz1zrh.js";
+import {
+  createPtyClient2,
+  createPersistentPtyClient2
+} from "../chunks/contract-gne7h7mq.js";
+import {
+  lastAssistantWithUsage2
+} from "../chunks/contract-8s2anffy.js";
+export {
+  createClientConnection2 as createClientConnection,
+  createData2 as createData,
+  createPersistentPtyClient2 as createPersistentPtyClient,
+  createPtyClient2 as createPtyClient,
+  defaultIdleTimeout2 as defaultIdleTimeout,
+  foregroundIdleThreshold2 as foregroundIdleThreshold,
+  lastAssistantWithUsage2 as lastAssistantWithUsage,
+  locationKey2 as locationKey,
+  settleMs2 as settleMs
+};

package/dist/solid/pty.d.ts

@@ -0,0 +1,22 @@
+import type { ExperimentalPersistentPtyConnectTokenInput, OpenCodeClient, PtyConnectTokenInput } from "../promise";
+export type PtyClientOptions = {
+    readonly url: string;
+    readonly openSocket?: (url: URL) => WebSocket;
+};
+export type PtyConnectInput = {
+    readonly ptyID: PtyConnectTokenInput["ptyID"];
+    readonly location?: PtyConnectTokenInput["location"];
+    readonly cursor?: number;
+};
+export type PersistentPtyConnectInput = {
+    readonly ptyID: ExperimentalPersistentPtyConnectTokenInput["ptyID"];
+    readonly cursor: number;
+    readonly attachmentID: string;
+    readonly takeover?: boolean;
+};
+export declare function createPtyClient(api: OpenCodeClient, options: PtyClientOptions): {
+    connect(input: PtyConnectInput): Promise<WebSocket>;
+};
+export declare function createPersistentPtyClient(api: OpenCodeClient, options: PtyClientOptions): {
+    connect(input: PersistentPtyConnectInput): Promise<WebSocket>;
+};

package/dist/solid/pty.js

@@ -0,0 +1,8 @@
+import {
+  createPtyClient2,
+  createPersistentPtyClient2
+} from "../chunks/contract-gne7h7mq.js";
+export {
+  createPersistentPtyClient2 as createPersistentPtyClient,
+  createPtyClient2 as createPtyClient
+};

package/dist/solid/usage.d.ts

@@ -0,0 +1,9 @@
+import type { SessionMessageAssistant, SessionMessageInfo } from "../promise";
+/**
+ * The assistant step whose tokens fill the context window now: the latest one after the last completed
+ * compaction and before the revert boundary. Every client shows context usage from this step, so the TUI
+ * and the desktop app agree on it.
+ */
+export declare function lastAssistantWithUsage(messages: ReadonlyArray<SessionMessageInfo>, boundary?: string): (SessionMessageAssistant & {
+    tokens: NonNullable<SessionMessageAssistant["tokens"]>;
+}) | undefined;

package/dist/solid/usage.js

@@ -0,0 +1,6 @@
+import {
+  lastAssistantWithUsage2
+} from "../chunks/contract-8s2anffy.js";
+export {
+  lastAssistantWithUsage2 as lastAssistantWithUsage
+};

package/package.json

@@ -1,6 +1,90 @@
 {
+  "$schema": "https://json.schemastore.org/package.json",
   "name": "@kilocode/client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.0-v2-9",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kilo-Org/kilocode.git",
+    "directory": "packages/client"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/promise/index.js",
+      "types": "./dist/promise/index.d.ts"
+    },
+    "./promise": {
+      "import": "./dist/promise/index.js",
+      "types": "./dist/promise/index.d.ts"
+    },
+    "./promise/api": {
+      "import": "./dist/promise/api.js",
+      "types": "./dist/promise/api.d.ts"
+    },
+    "./service": {
+      "import": "./dist/promise/service.js",
+      "types": "./dist/promise/service.d.ts"
+    },
+    "./solid": {
+      "import": "./dist/solid/index.js",
+      "types": "./dist/solid/index.d.ts"
+    },
+    "./effect": {
+      "import": "./dist/effect/index.js",
+      "types": "./dist/effect/index.d.ts"
+    },
+    "./effect/api": {
+      "import": "./dist/effect/api.js",
+      "types": "./dist/effect/api.d.ts"
+    },
+    "./effect/service": {
+      "import": "./dist/effect/service.js",
+      "types": "./dist/effect/service.d.ts"
+    },
+    "./mcp": {
+      "import": "./dist/mcp.js",
+      "types": "./dist/mcp.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run script/build-package.ts",
+    "generate": "bun run script/build.ts",
+    "check:generated": "bun run generate && git diff --exit-code -- src/promise/generated src/effect/generated src/effect/api",
+    "test": "bun test --timeout 5000",
+    "typecheck": "bun check --no-script",
+    "typecheck:tsc": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@opencode/schema": "npm:@kilocode/schema@0.0.0-v2-9",
+    "@opencode/protocol": "npm:@kilocode/protocol@0.0.0-v2-9"
+  },
+  "peerDependencies": {
+    "effect": "4.0.1",
+    "solid-js": ">=1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "effect": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.1",
+    "@modelcontextprotocol/client": "2.3.1",
+    "@opencode/httpapi-codegen": "2.1.3",
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.4.3",
+    "@typescript/native": "npm:typescript@7.1.0-beta",
+    "effect": "4.0.1",
+    "solid-js": "1.9.15"
+  }
+}