@rigkit/provider-cmux 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/provider-cmux",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "type": "module",
   "repository": {
     "type": "git",
@@ -17,8 +17,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@rigkit/sdk": "0.2.3",
-    "@rigkit/engine": "0.2.3"
+    "@rigkit/sdk": "0.2.4",
+    "@rigkit/engine": "0.2.4"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/host.ts

@@ -13,7 +13,11 @@ import {
   type CmuxWaitForRemoteOptions,
   type CmuxWorkspace,
 } from "./index.ts";
-import { defineHostCapability, type HostCapabilityHandler } from "@rigkit/sdk/host";
+import {
+  defineHostCapability,
+  type HostCapabilityContext,
+  type HostCapabilityHandler,
+} from "@rigkit/sdk/host";
 import {
   CMUX_OPEN_CAPABILITY,
   type CmuxOpenInput,
@@ -39,6 +43,7 @@ export type CmuxOpenClient = Pick<
 export type CmuxOpenHostOptions = {
   client?: CmuxOpenClient;
   clientOptions?: CmuxClientOptions;
+  logger?: (message: string) => void;
 };
 
 export function createCmuxOpenHostCapability(
@@ -46,7 +51,11 @@ export function createCmuxOpenHostCapability(
 ): CmuxHostCapabilityHandler {
   return defineHostCapability(CMUX_OPEN_CAPABILITY.id, {
     schemaHash: CMUX_OPEN_CAPABILITY.schemaHash,
-    handle: async (params) => await openCmux(params, options),
+    handle: async (params, context) =>
+      await openCmux(params, {
+        ...options,
+        logger: options.logger ?? hostCapabilityLogger(context) ?? options.clientOptions?.logger,
+      }),
   });
 }
 
@@ -57,18 +66,26 @@ export async function openCmux(
   options: CmuxOpenHostOptions = {},
 ): Promise<CmuxOpenResult> {
   const input = parseCmuxOpenInput(params);
-  const cmux = options.client ?? createCmuxClient(options.clientOptions);
+  const logger = cmuxOpenLogger(options);
+  const cmux = options.client ?? createCmuxClient({
+    ...options.clientOptions,
+    ...(options.logger ? { logger: options.logger } : {}),
+    printCommands: options.clientOptions?.printCommands ?? false,
+  });
   const command = commandForInput(input);
   let workspace: CmuxWorkspace;
   let terminalPane: CmuxPane | undefined;
 
+  logger?.(`cmux: opening ${input.name}`);
   if (input.ssh) {
+    logger?.("cmux: connecting remote workspace");
     workspace = await cmux.ssh({
       ...cmuxSshOptionsForInput(input.ssh),
       name: input.name,
       noFocus: input.focus === false,
     });
   } else {
+    logger?.("cmux: creating workspace");
     const workspaceOptions: CmuxNewWorkspaceOptions = {
       name: input.name,
       cwd: input.cwd,
@@ -81,6 +98,7 @@ export async function openCmux(
   const workspaceId = workspace.id ?? workspace.handle;
 
   if (input.ssh && command) {
+    logger?.(input.cwd ? `cmux: starting command in ${input.cwd}` : "cmux: starting command");
     const paneOptions: CmuxNewPaneOptions = {
       workspace: workspaceId,
       type: "terminal",
@@ -98,10 +116,12 @@ export async function openCmux(
 
   const waitOptions = remoteReadyOptionsForInput(input);
   if (input.ssh && waitOptions) {
+    logger?.("cmux: waiting for remote ports");
     await cmux.waitForRemoteReady(workspaceId, waitOptions);
   }
 
   if (input.ssh && terminalPane?.surface) {
+    logger?.("cmux: refreshing remote ports");
     const kickOptions: CmuxPortsKickOptions = {
       workspace: workspaceId,
       surface: terminalPane.surface,
@@ -112,6 +132,7 @@ export async function openCmux(
 
   let browserPane: CmuxPane | undefined;
   if (input.url) {
+    logger?.(`cmux: opening ${input.url}`);
     const browserOptions: CmuxBrowserOpenOptions = {
       workspace: workspaceId,
       url: input.url,
@@ -121,9 +142,11 @@ export async function openCmux(
   }
 
   if (input.focus !== false) {
+    logger?.("cmux: focusing workspace");
     await cmux.selectWorkspace(workspaceId);
   }
 
+  logger?.(`cmux: ready ${input.name}`);
   return {
     sessionId: workspaceId,
     workspaceId,
@@ -135,6 +158,15 @@ export async function openCmux(
   };
 }
 
+function cmuxOpenLogger(options: CmuxOpenHostOptions): ((message: string) => void) | undefined {
+  return options.logger ?? options.clientOptions?.logger;
+}
+
+function hostCapabilityLogger(context: HostCapabilityContext | undefined): ((message: string) => void) | undefined {
+  if (!context) return undefined;
+  return (message) => context.log(message, { label: "cmux" });
+}
+
 export function parseCmuxOpenInput(value: unknown): CmuxOpenInput {
   if (!isRecord(value)) throw new Error(`cmux.open requires an object input`);
   const name = requiredString(value, "name");

package/src/index.test.ts

@@ -402,6 +402,7 @@ describe("cmux sdk", () => {
 
   test("handles cmux.open host capability for an ssh workspace", async () => {
     const calls: Array<{ method: string; params: unknown }> = [];
+    const logs: string[] = [];
     const client = fakeOpenClient(calls);
 
     const result = await openCmux({
@@ -414,7 +415,7 @@ describe("cmux sdk", () => {
       cwd: "/workspace/site",
       command: "pnpm dev",
       url: "http://localhost:4321",
-    }, { client });
+    }, { client, logger: (message) => logs.push(message) });
 
     expect(result).toEqual({
       sessionId: "workspace-1",
@@ -480,6 +481,16 @@ describe("cmux sdk", () => {
       },
     ]);
     expect(calls[0]?.params).not.toHaveProperty("terminalStartupCommand");
+    expect(logs).toEqual([
+      "cmux: opening website",
+      "cmux: connecting remote workspace",
+      "cmux: starting command in /workspace/site",
+      "cmux: waiting for remote ports",
+      "cmux: refreshing remote ports",
+      "cmux: opening http://localhost:4321",
+      "cmux: focusing workspace",
+      "cmux: ready website",
+    ]);
   });
 
   test("forwards an explicit cmux ssh terminal startup command", async () => {
@@ -513,8 +524,10 @@ describe("cmux sdk", () => {
     const controller = await cmuxProviderPlugin.createProvider({
       provider: { providerId: "cmux", config: {} },
       storage: memoryProviderStorage("cmux"),
+      hostStorage: memoryProviderStorage("cmux"),
+      local: { open: async () => {} },
     });
-    const requests: Array<{ capability: string; params: unknown }> = [];
+    const requests: Array<{ capability: string; params: unknown; options: unknown }> = [];
     const runtime = await controller.runtime({
       workflow: "test",
       nodePath: "operation.open",
@@ -525,8 +538,8 @@ describe("cmux sdk", () => {
       metadata: () => {},
       local: {
         open: async () => {},
-        requestCapability: async <Result,>(capability: string, params: unknown) => {
-          requests.push({ capability, params });
+        requestCapability: async <Result,>(capability: string, params: unknown, options: unknown) => {
+          requests.push({ capability, params, options });
           return { sessionId: "workspace-1", workspaceId: "workspace-1" } as Result;
         },
       },
@@ -538,6 +551,7 @@ describe("cmux sdk", () => {
       {
         capability: "cmux.open",
         params: { name: "workspace" },
+        options: { nodePath: "operation.open" },
       },
     ]);
     expect(session.sessionId).toBe("workspace-1");
@@ -554,6 +568,8 @@ describe("cmux sdk", () => {
     const controller = await cmuxProviderPlugin.createProvider({
       provider: { providerId: "cmux", config: {} },
       storage: memoryProviderStorage("cmux"),
+      hostStorage: memoryProviderStorage("cmux"),
+      local: { open: async () => {} },
     });
     let resolveClosed!: () => void;
     const runtime = await controller.runtime({
@@ -566,9 +582,10 @@ describe("cmux sdk", () => {
       metadata: () => {},
       local: {
         open: async () => {},
-        requestCapabilitySession: async <Result,>(capability: string, params: unknown) => {
+        requestCapabilitySession: async <Result,>(capability: string, params: unknown, options: unknown) => {
           expect(capability).toBe("cmux.open");
           expect(params).toEqual({ name: "workspace" });
+          expect(options).toEqual({ nodePath: "operation.open" });
           return {
             result: { sessionId: "workspace-1", workspaceId: "workspace-1" } as Result,
             closed: new Promise<void>((resolve) => {

package/src/provider.ts

@@ -37,24 +37,25 @@ export const cmuxProviderPlugin: BaseProviderPlugin = {
     return {
       providerId: CMUX_PROVIDER_ID,
       runtime(context) {
-        return createCmuxRuntime(context.local);
+        return createCmuxRuntime(context.local, context.nodePath);
       },
     };
   },
 };
 
-function createCmuxRuntime(local: LocalWorkspaceRuntime): CmuxRuntime {
+function createCmuxRuntime(local: LocalWorkspaceRuntime, nodePath: string): CmuxRuntime {
   return {
-    open: async (input) => await requestCmuxOpen(local, input),
+    open: async (input) => await requestCmuxOpen(local, input, { nodePath }),
   };
 }
 
 export async function requestCmuxOpen(
   local: LocalWorkspaceRuntime,
   input: CmuxOpenInput,
+  options: { nodePath?: string } = {},
 ): Promise<CmuxOpenSession> {
   if (local.requestCapabilitySession) {
-    const session = await local.requestCapabilitySession<CmuxOpenResult>(CMUX_OPEN_CAPABILITY_ID, input);
+    const session = await local.requestCapabilitySession<CmuxOpenResult>(CMUX_OPEN_CAPABILITY_ID, input, options);
     return {
       ...parseCmuxOpenResult(session.result),
       closed: session.closed,
@@ -64,7 +65,7 @@ export async function requestCmuxOpen(
     throw new Error(`Host capability ${CMUX_OPEN_CAPABILITY_ID} is unavailable in this runtime`);
   }
   const result = parseCmuxOpenResult(
-    await local.requestCapability(CMUX_OPEN_CAPABILITY_ID, input),
+    await local.requestCapability(CMUX_OPEN_CAPABILITY_ID, input, options),
   );
   return {
     ...result,

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_PROVIDER_CMUX_VERSION = "0.2.3";
+export const RIGKIT_PROVIDER_CMUX_VERSION = "0.2.4";