@lmctl-ai/lmctl 0.2.37 → 0.2.39

package/dist/providers/transport-errors.d.ts

@@ -1,94 +0,0 @@
-/**
- * Named error taxonomy for the transport layer (claude stream-json,
- * codex app-server, ACP). Replaces the prior `new Error("RPC error: ...")`
- * string-dump pattern with typed classes that preserve structured fields
- * so downstream callers can branch on numeric codes / inspect the raw
- * line / read the original cause without re-parsing the message.
- *
- * Shape mirrors the claude-agent-sdk-python error hierarchy
- * (CLIConnectionError / CLINotFoundError / ProcessError /
- * CLIJSONDecodeError / MessageParseError) flagged in
- * `tasks/83-claude-sdk-research.md` §4 takeaway 3, and the
- * `createRpcError` helper that the codex-app-server transport
- * adopted from openai/codex-plugin-cc (research:
- * `tasks/83-codex-transport-compare.md`).
- *
- * All classes extend `TransportError`, which extends `Error` — every
- * instance still satisfies `instanceof Error` so existing
- * `try/catch (e: unknown)` sites continue to work without changes.
- * The added discriminator is `instanceof TransportError` (and the
- * specific subclasses) for callers who want the structured fields.
- *
- * The existing `TurnAbortError` (in `base-adapter.ts`) is a separate
- * concern — user-/idle-/provider-cancel reasons surfaced by the
- * higher-level chat orchestrator — and lives outside this taxonomy.
- */
-/**
- * Base class for transport-layer failures. Carries `name` set to the
- * concrete subclass name (so error messages on uncaught throws
- * identify the subtype) and propagates `cause` per the standard
- * Error options shape.
- */
-export declare class TransportError extends Error {
-    constructor(message: string, options?: {
-        cause?: unknown;
-    });
-}
-/**
- * Failed to establish or maintain the subprocess/stdio channel.
- * Examples: `spawn` ENOENT, `spawn` permission denied, write to
- * already-closed stdin during a transport-level shutdown.
- */
-export declare class TransportConnectionError extends TransportError {
-}
-/**
- * The subprocess exited unexpectedly — either before the protocol
- * reached its terminal state, or with a non-zero exit code that the
- * transport considers an error condition.
- *
- * `exitCode` is `null` when the child was killed by signal without an
- * explicit exit code; `signal` carries the POSIX signal name in that
- * case (e.g. `"SIGKILL"`). `stderr` is best-effort — the transport
- * captures the tail of the child's stderr if it was piped.
- */
-export declare class TransportProcessError extends TransportError {
-    readonly exitCode: number | null;
-    readonly signal: string | null;
-    readonly stderr?: string | undefined;
-    constructor(message: string, exitCode: number | null, signal?: string | null, stderr?: string | undefined);
-}
-/**
- * A line read off the wire could not be JSON-parsed. The raw `line`
- * is preserved (truncated to a sane length by the caller before
- * construction if it could be very large) so investigators can see
- * exactly what the transport rejected. `cause` is the original
- * `SyntaxError` from `JSON.parse`.
- */
-export declare class TransportJsonError extends TransportError {
-    readonly line: string;
-    constructor(message: string, line: string, cause: unknown);
-}
-/**
- * The peer responded with a JSON-RPC error object. `rpcCode` is the
- * numeric code from the JSON-RPC `error.code` field when present, and
- * `rpcData` carries the entire `error` payload (including `message`,
- * `data`, and any provider-specific fields like
- * codex-plugin-cc's broker-busy sentinel `-32001`).
- *
- * Callers who care about specific codes branch on `err.rpcCode`;
- * generic catchers see a plain `Error` with a human-readable message.
- */
-export declare class TransportRpcError extends TransportError {
-    readonly rpcCode?: number;
-    readonly rpcData?: unknown;
-    constructor(message: string, rpcCode?: number, rpcData?: unknown);
-}
-/**
- * Convenience constructor that mirrors the prior `createRpcError`
- * helper signature in `codex-app-server.ts`: pass the human message
- * plus the raw JSON-RPC error object, and the helper extracts
- * `code` (if numeric) and stores the whole object as `rpcData`.
- *
- * This is the migration target for `createRpcError` callers.
- */
-export declare function transportRpcErrorFromResponse(message: string, errorObj?: unknown): TransportRpcError;

package/dist/providers/transport-lifecycle.d.ts

@@ -1,63 +0,0 @@
-/**
- * Graceful-shutdown ladder for transport child processes.
- *
- * Replaces the prior `child.kill()` (synchronous, hard SIGTERM, no
- * grace) pattern across the claude / codex / ACP transports. The bug
- * this fixes is documented in the claude-agent-sdk-python transport
- * (`subprocess_cli.py:548-568` and the linked issue #625): when
- * `claude` is killed mid-flush its session JSONL loses the last
- * assistant message. The same risk class applies to any provider CLI
- * that persists state on shutdown — codex (`thread/*.jsonl`),
- * opencode (`opencode.db`), gemini (`~/.gemini/tmp/.../chats/`).
- *
- * Ladder:
- *   1. (optional) close stdin so the child observes EOF.
- *   2. wait `softDelayMs` for the child to exit on its own.
- *   3. send SIGTERM (or `taskkill /T /F /PID <pid>` on Windows) and
- *      wait `killDelayMs`.
- *   4. send SIGKILL (no-op on Windows, taskkill is already hard).
- *   5. wait up to a fixed final grace for the exit event before
- *      returning.
- *
- * Returns a `TerminateResult` describing which path actually ended
- * the child and total elapsed wall-clock — useful for tests and for
- * future telemetry on shutdown latency.
- */
-import type { ChildProcess } from "node:child_process";
-export interface TerminateOptions {
-    /** Call `child.stdin?.end()` first to signal clean EOF. Default: true. */
-    stdinEnd?: boolean;
-    /** Wait ms for child to exit naturally after stdin.end. Default: 5000. */
-    softDelayMs?: number;
-    /** Wait ms after SIGTERM before SIGKILL. Default: 5000. */
-    killDelayMs?: number;
-    /**
-     * Test seam — replace the Windows process-tree killer
-     * (`taskkill /T /F /PID <pid>`) with a no-op or recorder. Defaults
-     * to a real `spawnSync("taskkill", ...)` call on Windows; ignored
-     * on Unix.
-     */
-    runTaskkill?: (pid: number) => void;
-    /** Test seam — override `process.platform`. */
-    platform?: NodeJS.Platform;
-}
-/** Which step in the ladder actually finished the child. */
-export type TerminateSignal = "natural" | "stdin" | "SIGTERM" | "SIGKILL" | "abandoned";
-export interface TerminateResult {
-    signal: TerminateSignal;
-    elapsedMs: number;
-}
-/**
- * Gracefully terminate a transport child process.
- *
- * Safe to call on an already-exited child (returns immediately with
- * `signal: "natural"`). Safe to call multiple times concurrently
- * — each call observes the same exit event independently.
- *
- * Errors are swallowed deliberately: this function is meant to be
- * called from cleanup paths (abort handlers, IIFE catch blocks,
- * timeout firings) where re-throwing would mask the original
- * failure. Failures during termination are reflected in the returned
- * `TerminateResult.signal` (`"abandoned"` is the only failure shape).
- */
-export declare function terminateGracefully(child: ChildProcess, opts?: TerminateOptions): Promise<TerminateResult>;

package/dist/providers/transport-wrappers.d.ts

@@ -1,110 +0,0 @@
-/**
- * Transport wrappers for use by provider adapters.
- * These wrap the existing transport modules, mapping their result types
- * to the adapter's TurnResult.
- *
- * Each wrapper also classifies the transport's native event stream into
- * normalized ProgressEvents (see adapter.ts) so that downstream consumers
- * (idle timer, stderr printer) have a single format to deal with.
- */
-import { type AcpMode } from "./transports/acp.js";
-import type { ProgressEvent, TurnOptions, TurnResult } from "./adapter.js";
-import type { BundleSession, BundleSessionOpenOptions } from "./bundle.js";
-/**
- * Translate one stream-json event into zero or more ProgressEvents.
- * Stream-json uses Claude's native message format:
- *   - {"type":"system","subtype":"init",...}
- *   - {"type":"assistant","message":{"content":[{type:"text"|"tool_use"|"thinking"...}]}}
- *   - {"type":"user","message":{"content":[{type:"tool_result",...}]}}
- *   - {"type":"result",...}
- */
-/**
- * Stateful factory for classifyStreamJsonEvent. The returned closure
- * carries a per-turn id→startMs Map that lets it populate `elapsedMs`
- * on tool_result events by correlating against the matching tool_use
- * (Claude stream-json doesn't supply duration directly).
- *
- * Production callers (`streamJsonTurn`) instantiate ONCE per turn and
- * reuse across all events. Unit tests that exercise a single event in
- * isolation can keep using the bare `classifyStreamJsonEvent` free
- * function below — they just won't get elapsedMs populated, which is
- * fine because there's no matching pair to compute it from.
- */
-export declare function makeStreamJsonClassifier(): (event: Record<string, unknown>, emit: (e: ProgressEvent) => void) => void;
-export declare function classifyStreamJsonEvent(event: Record<string, unknown>, emit: (e: ProgressEvent) => void): void;
-export declare function streamJsonTurn(prompt: string, opts: TurnOptions & {
-    binary: string;
-}): Promise<TurnResult>;
-/**
- * Open a persistent stream-json bundle session (batch bundle mode)
- * for the claude/qwen adapters' `openSession`. Bundle resume is strict:
- * the session file must exist and its header must carry the requested id.
- */
-export declare function openStreamJsonBundleSession(opts: BundleSessionOpenOptions & {
-    binary: string;
-}): Promise<BundleSession>;
-/**
- * Classify ACP session/update notifications. ACP wraps everything in
- *   {"method":"session/update","params":{"update":{"sessionUpdate":"<kind>",...}}}
- *
- * Common sessionUpdate kinds (per the ACP spec used by Zed and friends):
- *   - agent_message_chunk      → text (already streamed via onDelta)
- *   - agent_thought_chunk      → thinking
- *   - tool_call                → tool_use
- *   - tool_call_update         → tool_result (completed/failed), other "running…" (in_progress)
- *   - plan                     → other
- */
-/**
- * Stateful factory for classifyAcpEvent. Same shape and rationale as
- * makeStreamJsonClassifier — see that doc. Carries per-turn id→startMs
- * for the tool_call → tool_call_update correlation that drives
- * `elapsedMs` on tool_result events.
- */
-export declare function makeAcpClassifier(): (event: Record<string, unknown>, emit: (e: ProgressEvent) => void) => void;
-export declare function classifyAcpEvent(event: Record<string, unknown>, emit: (e: ProgressEvent) => void): void;
-export declare function acpTurn(prompt: string, opts: TurnOptions & {
-    binary: string;
-    acpTool?: string;
-    acpMode?: AcpMode;
-}): Promise<TurnResult>;
-/**
- * Open a persistent ACP bundle session (batch bundle mode) for a
- * provider adapter's `openSession` implementation. `acpTool`/`acpMode`
- * mirror `acpTurn`; the lifecycle contract is in
- * `src/providers/bundle.ts` and the engine in `transports/acp.ts`'s
- * `openAcpSession`.
- *
- * Bundle resume is ALWAYS strict: requireResume is forced and the loaded
- * session id must equal the requested id exactly.
- */
-export declare function openAcpBundleSession(opts: BundleSessionOpenOptions & {
-    binary: string;
-    acpTool?: string;
-    acpMode?: AcpMode;
-}): Promise<BundleSession>;
-/**
- * Classify Codex app-server JSON-RPC notifications.
- *
- * Per codex-rs/app-server/README.md (Turn events / Items), the per-item
- * lifecycle is always: `item/started` → zero or more item-specific deltas
- * → `item/completed`. Items are a tagged union (`item.type`) including
- * `commandExecution`, `fileChange`, `mcpToolCall`, `webSearch`, `reasoning`,
- * `agentMessage`, etc.
- *
- * Item-specific deltas we care about:
- *   - item/agentMessage/delta              → text (already streamed via onDelta)
- *   - item/reasoning/summaryTextDelta      → thinking
- *   - item/reasoning/textDelta             → thinking
- *   - item/commandExecution/outputDelta    → text (suppressed; lifecycle covers it)
- */
-export declare function classifyCodexEvent(event: Record<string, unknown>, emit: (e: ProgressEvent) => void): void;
-export declare function codexAppServerTurn(prompt: string, opts: TurnOptions & {
-    binary: string;
-}): Promise<TurnResult>;
-/**
- * Open a persistent codex app-server bundle session (batch bundle
- * mode) for the codex adapter's `openSession`. Bundle resume is
- * strict: thread/resume must succeed and return the exact requested
- * thread id; the thread/start fallback is disabled in bundle mode.
- */
-export declare function openCodexBundleSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;

package/dist/providers/transports/acp-profiles/config-option-step.d.ts

@@ -1,24 +0,0 @@
-/**
- * Shared `session/set_config_option` step factory for the profiles whose
- * per-session model/effort surface is an ACP config option (opencode, kimi).
- *
- * The failure semantics are NON-FATAL by contract (task #232): the turn
- * proceeds with whatever config was already active, and the drop is
- * recorded on all three channels — stderr line, `acp_config_option_failed`
- * errorLog record, and a warnings-channel entry that lands on
- * `AcpResult.warnings`.
- *
- * "_failed", not "_rejected": the driver's catch wraps `sendRpc`, so it
- * also fires on transport disconnect, not only on the provider rejecting
- * the value. Naming it "rejected" would conflate provider-validation noise
- * with channel failure — exactly the misreading these counts exist to
- * prevent.
- */
-import type { AcpSessionContext, AcpSessionStep } from "./types.js";
-export declare function setConfigOptionStep(opts: {
-    id: string;
-    provider: string;
-    configId: string;
-    /** The requested value; undefined ⇒ the step does not apply. */
-    value: (ctx: AcpSessionContext) => string | undefined;
-}): AcpSessionStep;

package/dist/providers/transports/acp-profiles/copilot.d.ts

@@ -1,12 +0,0 @@
-/**
- * Copilot ACP profile.
- *
- * Copilot's `--acp` mode has no plan-mode flag and no per-session model
- * selection surface (verified against copilot-cli 1.0.35). Both gaps are
- * surfaced once per spawn — a stderr line the user sees plus an
- * unconditional errorLog record fleet tooling can count — and the turn
- * proceeds on the yolo/default surface rather than hanging on permission
- * prompts it cannot answer.
- */
-import type { AcpProviderProfile } from "./types.js";
-export declare const copilotProfile: AcpProviderProfile;

package/dist/providers/transports/acp-profiles/gemini.d.ts

@@ -1,22 +0,0 @@
-/**
- * Gemini ACP profile.
- *
- * Permission posture is argv-based: `-y` (yolo) works before or after
- * `--acp`, and the companion `--skip-trust` is passed unconditionally —
- * gemini's workspace-trust gate (~/.gemini/trustedFolders.json) downgrades
- * approval mode to "default" in untrusted folders, silently disarming
- * `-y`; `--skip-trust` is the per-invocation escape hatch (no-op in
- * already-trusted folders). Plan mode swaps the `-y` token for
- * `--approval-mode plan`, keeping companions intact.
- *
- * Caveat: gemini's `--approval-mode plan` only filters `write_file` by
- * workspace path — the agent can still escape via `run_shell_command`
- * (documented in yolo-contract.ts; a tighter sandbox is a follow-up).
- *
- * Gemini replays prior assistant chunks during `session/load` and
- * concatenates earlier image turns into the reply text; keeping only the
- * latest agent message is the output processor's job (parsers/acp.ts),
- * wired in via `isolateResult`.
- */
-import type { AcpProviderProfile } from "./types.js";
-export declare const geminiProfile: AcpProviderProfile;

package/dist/providers/transports/acp-profiles/hermes.d.ts

@@ -1,27 +0,0 @@
-/**
- * Hermes (Hermes Agent) ACP profile.
- *
- * `hermes acp` IS the ACP stdio server (same launcher as the `hermes-acp`
- * console script); it takes no permission flag. The posture is two-part:
- *
- *  1. Shell gate: `HERMES_YOLO_MODE=1` on the process env (yolo mode only;
- *     hermes REFUSES plan mode outright).
- *  2. Edit gate: ACP `session/set_mode` — Hermes's mode ladder
- *     (`HermesACPAgent._MODES`, `acp_adapter/server.py:233-243`) governs
- *     the file-EDIT approval gate, which `HERMES_YOLO_MODE` does NOT
- *     approve. An unset mode leaves every edit waiting on a
- *     `session/request_permission` round-trip lmctl cannot answer, so the
- *     mode is applied after session/new|load, before the model, on EVERY
- *     spawn (the mode lives on the in-memory session), FAIL-CLOSED.
- *
- * Model selection is `session/set_model` (also fail-closed), NOT
- * `session/set_config_option`: hermes's config-option handler stores an
- * unrecognized configId verbatim and applies nothing
- * (`acp_adapter/server.py:958-977`). Its model ids are the ENCODED
- * `provider:model` form it advertises in session/new
- * (`acp_adapter/model_catalog.py:146-152`) — a bare model name resolves
- * the wrong provider. An unchanged model is not re-set (avoids rebuilding
- * the Hermes agent).
- */
-import type { AcpProviderProfile } from "./types.js";
-export declare const hermesProfile: AcpProviderProfile;

package/dist/providers/transports/acp-profiles/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * ACP provider profile registry.
- *
- * The generic ACP engine (transports/acp.ts) looks up the profile for a
- * tool here; everything provider-specific lives in the profile modules.
- */
-import type { AcpProviderProfile } from "./types.js";
-export declare function acpProfileForTool(tool: string): AcpProviderProfile | undefined;
-/**
- * Read-only view of the per-profile `{ binary, baseArgs }` table for
- * tests that pin the per-provider argv shape (e.g. flag-position
- * regression checks). Production code reads the profiles directly; this
- * alias exists only so the test suite can import a frozen view without
- * making the table mutable from the outside.
- */
-export declare const ACP_TOOLS_FOR_TEST: Readonly<Record<string, Readonly<{
-    binary: string;
-    args: readonly string[];
-}>>>;

package/dist/providers/transports/acp-profiles/kimi.d.ts

@@ -1,24 +0,0 @@
-/**
- * Kimi ACP profile.
- *
- * Kimi's ACP subcommand has no argv permission flag: the posture is
- * protocol-level (`session/set_config_option` with configId "mode"),
- * applied BEFORE any model config and BEFORE the first prompt, and it is
- * FAIL-CLOSED — lmctl cannot answer `session/request_permission`, so a
- * rejected mode change would leave the subprocess hung on its first tool
- * call. Ordering and policy are the `sessionSetup` data below.
- *
- * Kimi 0.28.x exposes only an on/off thinking toggle, so a declared
- * `effort=` cannot be honored here and is silently ignored.
- */
-import type { AcpProviderProfile } from "./types.js";
-export declare function detectKimiRuntimeDead(resultText: string): string | null;
-/**
- * Kimi logs a multi-line `Error handling notification … -32601 Method not
- * found` block for the mandatory `notifications/initialized` notification
- * on every spawn. It is routine, not a failure — strip exactly that block
- * (and only that block) from the stderr tail attached to a no-result
- * error report.
- */
-export declare function filterKimiExpectedStderr(stderr: string): string;
-export declare const kimiProfile: AcpProviderProfile;

package/dist/providers/transports/acp-profiles/opencode.d.ts

@@ -1,26 +0,0 @@
-/**
- * OpenCode ACP profile.
- *
- * OpenCode's ACP mode rejects every permission-bypass argv flag
- * (`--dangerously-skip-permissions` is a `run`-subcommand-only flag,
- * verified empirically). YOLO is satisfied via
- * `<cwd>/.opencode/opencode.json` carrying `"permission": "allow"`,
- * installed defensively before every chat spawn (preSpawn) so even
- * pre-fix-seeded teams get the YOLO key without a re-create. The install
- * no longer writes lmctl MCP entries.
- *
- * The profile also owns `probeOpenCodeAcpConfig` — a separate probe entry
- * point (purpose "probe") used by lint/seed via teamfile-compat.ts. It
- * intentionally differs from the chat spawn: no runtime permission-config
- * install (initialize/session creation and config-option validation
- * cannot request tools or incur an LLM call), and a rejected model/effort
- * option is reported as probe evidence rather than absorbed as a warning.
- */
-import type { AcpProviderProfile, OpenCodeAcpConfigProbeOptions, OpenCodeAcpConfigProbeResult } from "./types.js";
-export declare const openCodeProfile: AcpProviderProfile;
-/**
- * Verify opencode's live per-session model/effort contract without prompting.
- * No project permission config is installed: initialize/session creation and
- * config-option validation cannot request tools or incur an LLM call.
- */
-export declare function probeOpenCodeAcpConfig(opts: OpenCodeAcpConfigProbeOptions): Promise<OpenCodeAcpConfigProbeResult>;