oh-my-opencode 3.16.0 → 3.17.0

package/dist/features/skill-mcp-manager/connection.d.ts

@@ -1,15 +1,14 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
-import type { SkillMcpClientInfo, SkillMcpManagerState } from "./types";
+import type { McpClient, SkillMcpClientInfo, SkillMcpManagerState } from "./types";
 export declare function getOrCreateClient(params: {
     state: SkillMcpManagerState;
     clientKey: string;
     info: SkillMcpClientInfo;
     config: ClaudeCodeMcpServer;
-}): Promise<Client>;
+}): Promise<McpClient>;
 export declare function getOrCreateClientWithRetryImpl(params: {
     state: SkillMcpManagerState;
     clientKey: string;
     info: SkillMcpClientInfo;
     config: ClaudeCodeMcpServer;
-}): Promise<Client>;
+}): Promise<McpClient>;

package/dist/features/skill-mcp-manager/http-client.d.ts

@@ -1,3 +1,17 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { SkillMcpClientConnectionParams } from "./types";
-export declare function createHttpClient(params: SkillMcpClientConnectionParams): Promise<Client>;
+import type { McpClient, McpTransport, SkillMcpClientConnectionParams } from "./types";
+type HttpClientFactory = (clientInfo: {
+    name: string;
+    version: string;
+}, options: {
+    capabilities: Record<string, never>;
+}) => McpClient;
+type HttpTransportFactory = (url: URL, options?: {
+    requestInit?: RequestInit;
+}) => McpTransport;
+interface HttpClientDependencies {
+    createClient: HttpClientFactory;
+    createTransport: HttpTransportFactory;
+}
+export declare function setHttpClientDependenciesForTesting(dependencies?: Partial<HttpClientDependencies>): void;
+export declare function createHttpClient(params: SkillMcpClientConnectionParams): Promise<McpClient>;
+export {};

package/dist/features/skill-mcp-manager/manager.d.ts

@@ -1,14 +1,13 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { Prompt, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
 import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
-import type { OAuthProviderFactory, SkillMcpClientInfo, SkillMcpServerContext } from "./types";
+import type { McpClient, OAuthProviderFactory, SkillMcpClientInfo, SkillMcpServerContext } from "./types";
 export declare class SkillMcpManager {
     private readonly state;
     constructor(options?: {
         createOAuthProvider?: OAuthProviderFactory;
     });
     private getClientKey;
-    getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<Client>;
+    getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<McpClient>;
     disconnectSession(sessionID: string): Promise<void>;
     disconnectAll(): Promise<void>;
     listTools(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Tool[]>;

package/dist/features/skill-mcp-manager/stdio-client.d.ts

@@ -1,3 +1,16 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { SkillMcpClientConnectionParams } from "./types";
-export declare function createStdioClient(params: SkillMcpClientConnectionParams): Promise<Client>;
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { McpClient, McpTransport, SkillMcpClientConnectionParams } from "./types";
+type StdioClientFactory = (clientInfo: {
+    name: string;
+    version: string;
+}, options: {
+    capabilities: Record<string, never>;
+}) => McpClient;
+type StdioTransportFactory = (options: ConstructorParameters<typeof StdioClientTransport>[0]) => McpTransport;
+interface StdioClientDependencies {
+    createClient: StdioClientFactory;
+    createTransport: StdioTransportFactory;
+}
+export declare function setStdioClientDependenciesForTesting(dependencies?: Partial<StdioClientDependencies>): void;
+export declare function createStdioClient(params: SkillMcpClientConnectionParams): Promise<McpClient>;
+export {};

package/dist/features/skill-mcp-manager/types.d.ts

@@ -1,10 +1,20 @@
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
 import type { McpOAuthProvider } from "../mcp-oauth/provider";
 import type { SkillScope } from "../opencode-skill-loader/types";
 export type SkillMcpConfig = Record<string, ClaudeCodeMcpServer>;
+export type McpTransport = Transport;
+export interface McpClient {
+    connect: Client["connect"];
+    close: Client["close"];
+    listTools: Client["listTools"];
+    listResources: Client["listResources"];
+    listPrompts: Client["listPrompts"];
+    callTool: Client["callTool"];
+    readResource: Client["readResource"];
+    getPrompt: Client["getPrompt"];
+}
 export interface SkillMcpClientInfo {
     serverName: string;
     skillName: string;
@@ -22,18 +32,18 @@ export interface SkillMcpServerContext {
  */
 export type ConnectionType = "stdio" | "http";
 export interface ManagedClientBase {
-    client: Client;
+    client: McpClient;
     skillName: string;
     lastUsedAt: number;
     connectionType: ConnectionType;
 }
 export interface ManagedStdioClient extends ManagedClientBase {
     connectionType: "stdio";
-    transport: StdioClientTransport;
+    transport: McpTransport;
 }
 export interface ManagedHttpClient extends ManagedClientBase {
     connectionType: "http";
-    transport: StreamableHTTPClientTransport;
+    transport: McpTransport;
 }
 export type ManagedClient = ManagedStdioClient | ManagedHttpClient;
 export interface ProcessCleanupHandler {
@@ -48,7 +58,7 @@ export type OAuthProviderFactory = (options: {
 }) => OAuthProviderLike;
 export interface SkillMcpManagerState {
     clients: Map<string, ManagedClient>;
-    pendingConnections: Map<string, Promise<Client>>;
+    pendingConnections: Map<string, Promise<McpClient>>;
     disconnectedSessions: Map<string, number>;
     authProviders: Map<string, McpOAuthProvider>;
     cleanupRegistered: boolean;

package/dist/features/tmux-subagent/manager.d.ts

@@ -39,6 +39,7 @@ export declare class TmuxSessionManager {
     private spawnInIsolatedContainer;
     private getCapacityConfig;
     private getSessionMappings;
+    getTrackedPaneId(sessionId: string): string | undefined;
     private removeTrackedSession;
     private reassignIsolatedContainerAnchor;
     private cleanupIsolatedContainerAfterSessionDeletion;

package/dist/hooks/atlas/session-last-agent.d.ts

@@ -1,3 +1,12 @@
+import { getMessageDir, isSqliteBackend, normalizeSDKResponse } from "../../shared";
+import { hasCompactionPartInStorage, isCompactionMessage } from "../../shared/compaction-marker";
+type SessionLastAgentDeps = {
+    getMessageDir: typeof getMessageDir;
+    isSqliteBackend: typeof isSqliteBackend;
+    normalizeSDKResponse: typeof normalizeSDKResponse;
+    hasCompactionPartInStorage: typeof hasCompactionPartInStorage;
+    isCompactionMessage: typeof isCompactionMessage;
+};
 type SessionMessagesClient = {
     session: {
         messages: (input: {
@@ -7,5 +16,5 @@ type SessionMessagesClient = {
         }) => Promise<unknown>;
     };
 };
-export declare function getLastAgentFromSession(sessionID: string, client?: SessionMessagesClient): Promise<string | null>;
+export declare function getLastAgentFromSession(sessionID: string, client?: SessionMessagesClient, deps?: Partial<SessionLastAgentDeps>): Promise<string | null>;
 export {};

package/dist/hooks/auto-update-checker/constants.d.ts

@@ -1,4 +1,14 @@
 export declare const PACKAGE_NAME = "oh-my-opencode";
+/**
+ * All package names the canonical plugin may be published under.
+ *
+ * The package is published to npm as both `oh-my-opencode` (legacy canonical)
+ * and `oh-my-openagent` (current canonical). Any code that *reads* an
+ * installed package.json or walks up from an import path must accept both,
+ * because the installed name depends on which package the user added to
+ * their config. Code that *writes* continues to use {@link PACKAGE_NAME}.
+ */
+export declare const ACCEPTED_PACKAGE_NAMES: readonly ["oh-my-opencode", "oh-my-openagent"];
 export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/oh-my-opencode/dist-tags";
 export declare const NPM_FETCH_TIMEOUT = 5000;
 export declare const CACHE_ROOT_DIR: string;
@@ -9,3 +19,8 @@ export declare function getUserConfigDir(): string;
 export declare function getUserOpencodeConfig(): string;
 export declare function getUserOpencodeConfigJsonc(): string;
 export declare const INSTALLED_PACKAGE_JSON: string;
+/**
+ * Candidate paths where the installed package.json may live, in priority order.
+ * Readers should try each path in order and stop on the first success.
+ */
+export declare const INSTALLED_PACKAGE_JSON_CANDIDATES: string[];

package/dist/hooks/auto-update-checker/hook.d.ts

@@ -1,6 +1,26 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import { log } from "../../shared/logger";
 import type { AutoUpdateCheckerOptions } from "./types";
-export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions): {
+import { getCachedVersion, getLocalDevVersion } from "./checker";
+import { runBackgroundUpdateCheck } from "./hook/background-update-check";
+import { showConfigErrorsIfAny } from "./hook/config-errors-toast";
+import { updateAndShowConnectedProvidersCacheStatus } from "./hook/connected-providers-status";
+import { refreshModelCapabilitiesOnStartup } from "./hook/model-capabilities-status";
+import { showModelCacheWarningIfNeeded } from "./hook/model-cache-warning";
+import { showLocalDevToast, showVersionToast } from "./hook/startup-toasts";
+interface AutoUpdateCheckerDeps {
+    getCachedVersion: typeof getCachedVersion;
+    getLocalDevVersion: typeof getLocalDevVersion;
+    showConfigErrorsIfAny: typeof showConfigErrorsIfAny;
+    updateAndShowConnectedProvidersCacheStatus: typeof updateAndShowConnectedProvidersCacheStatus;
+    refreshModelCapabilitiesOnStartup: typeof refreshModelCapabilitiesOnStartup;
+    showModelCacheWarningIfNeeded: typeof showModelCacheWarningIfNeeded;
+    showLocalDevToast: typeof showLocalDevToast;
+    showVersionToast: typeof showVersionToast;
+    runBackgroundUpdateCheck: typeof runBackgroundUpdateCheck;
+    log: typeof log;
+}
+export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions, deps?: AutoUpdateCheckerDeps): {
     event: ({ event }: {
         event: {
             type: string;
@@ -8,3 +28,4 @@ export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?:
         };
     }) => void;
 };
+export {};

package/dist/hooks/comment-checker/cli-runner.d.ts

@@ -1,4 +1,5 @@
 import type { PendingCall } from "./types";
+import { runCommentChecker } from "./cli";
 export declare function initializeCommentCheckerCli(debugLog: (...args: unknown[]) => void): void;
 export declare function getCommentCheckerCliPathPromise(): Promise<string | null> | null;
 export declare function processWithCli(input: {
@@ -7,7 +8,9 @@ export declare function processWithCli(input: {
     callID: string;
 }, pendingCall: PendingCall, output: {
     output: string;
-}, cliPath: string, customPrompt: string | undefined, debugLog: (...args: unknown[]) => void): Promise<void>;
+}, cliPath: string, customPrompt: string | undefined, debugLog: (...args: unknown[]) => void, deps?: {
+    runCommentChecker?: typeof runCommentChecker;
+}): Promise<void>;
 export interface ApplyPatchEdit {
     filePath: string;
     before: string;

package/dist/hooks/keyword-detector/hook.d.ts

@@ -1,7 +1,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { ContextCollector } from "../../features/context-injector";
 import type { RalphLoopHook } from "../ralph-loop";
-export declare function createKeywordDetectorHook(ctx: PluginInput, _collector?: ContextCollector, ralphLoop?: Pick<RalphLoopHook, "startLoop">): {
+export declare function createKeywordDetectorHook(ctx: PluginInput, _collector?: ContextCollector, _ralphLoop?: Pick<RalphLoopHook, "startLoop">): {
     "chat.message": (input: {
         sessionID: string;
         agent?: string;

package/dist/hooks/read-image-resizer/image-resizer.d.ts

@@ -1,3 +1,5 @@
 import type { ImageDimensions, ResizeResult } from "./types";
 export declare function calculateTargetDimensions(width: number, height: number, maxLongEdge?: number): ImageDimensions | null;
-export declare function resizeImage(base64DataUrl: string, mimeType: string, target: ImageDimensions): Promise<ResizeResult | null>;
+export declare function resizeImage(base64DataUrl: string, mimeType: string, target: ImageDimensions, deps?: {
+    loadSharpModule?: () => Promise<unknown | null>;
+}): Promise<ResizeResult | null>;

package/dist/hooks/rules-injector/injector.d.ts

@@ -1,4 +1,8 @@
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import type { FindRuleFilesOptions } from "./rule-file-finder";
+import { createContentHash, isDuplicateByContentHash, isDuplicateByRealPath, shouldApplyRule } from "./matcher";
+import { saveInjectedRules } from "./storage";
 import type { SessionInjectedRulesCache } from "./cache";
 type ToolExecuteOutput = {
     title: string;
@@ -16,6 +20,14 @@ export declare function createRuleInjectionProcessor(deps: {
     truncator: DynamicTruncator;
     getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
     ruleFinderOptions?: FindRuleFilesOptions;
+    readFileSync?: typeof readFileSync;
+    statSync?: typeof statSync;
+    homedir?: typeof homedir;
+    shouldApplyRule?: typeof shouldApplyRule;
+    isDuplicateByRealPath?: typeof isDuplicateByRealPath;
+    createContentHash?: typeof createContentHash;
+    isDuplicateByContentHash?: typeof isDuplicateByContentHash;
+    saveInjectedRules?: typeof saveInjectedRules;
 }): {
     processFilePathForInjection: (filePath: string, sessionID: string, output: ToolExecuteOutput) => Promise<void>;
 };