@rigkit/provider-cmux 0.2.2 → 0.2.4

package/README.md

@@ -43,14 +43,13 @@ export default workflow("site", {
 })
   .sequence("site")
   .operation("open", {
-    requiredHostCapabilities: [cmux.capabilities.open],
     run: async ({ providers }) => {
       await providers.cmux.open({
         name: "site",
         ssh: {
-          host: "vm-ssh.freestyle.sh",
-          username: "vm_123",
-          auth: { type: "token", token: "token_123" },
+          host: "devbox.example.com",
+          username: "root",
+          sshOptions: ["ServerAliveInterval=15"],
         },
         cwd: "/workspace/site",
         command: "pnpm dev",

package/package.json

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

package/src/capabilities.ts

@@ -1,7 +1,7 @@
 export const CMUX_OPEN_CAPABILITY_ID = "cmux.open";
 
 export const CMUX_OPEN_SCHEMA_HASH =
-  "sha256:ed7f74b4fd1101ff87281c0269f9884f85783098d9a727fdfe05491efba2dd28";
+  "sha256:671373232fc79a7f75dd01c8c83c0c350af62b349a89bb3cfcc96af2cd76c878";
 
 export const CMUX_OPEN_CAPABILITY = {
   id: CMUX_OPEN_CAPABILITY_ID,
@@ -14,8 +14,6 @@ export type CmuxOpenSshInput = string | {
   host?: string;
   port?: number;
   username?: string;
-  auth?: { type: "token"; token: string } | { type: "privateKey"; privateKey: string };
-  command?: string;
   identity?: string;
   sshOptions?: readonly string[];
   remoteCommandArgs?: readonly string[];

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,23 +43,19 @@ export type CmuxOpenClient = Pick<
 export type CmuxOpenHostOptions = {
   client?: CmuxOpenClient;
   clientOptions?: CmuxClientOptions;
+  logger?: (message: string) => void;
 };
 
-const freestyleTokenSshOptions = [
-  "StrictHostKeyChecking=no",
-  "UserKnownHostsFile=/dev/null",
-  "LogLevel=ERROR",
-  "IdentitiesOnly=yes",
-  "IdentityFile=/dev/null",
-  "ControlMaster=no",
-] as const;
-
 export function createCmuxOpenHostCapability(
   options: CmuxOpenHostOptions = {},
 ): 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,
+      }),
   });
 }
 
@@ -66,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,
@@ -90,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",
@@ -107,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,
@@ -121,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,
@@ -130,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,
@@ -144,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");
@@ -171,8 +194,6 @@ function parseSshInput(value: unknown): CmuxOpenSshInput {
     ...optionalStringField(value, "host"),
     ...optionalNumberField(value, "port"),
     ...optionalStringField(value, "username"),
-    ...(value.auth !== undefined ? { auth: parseSshAuth(value.auth) } : {}),
-    ...optionalStringField(value, "command"),
     ...optionalStringField(value, "identity"),
     ...optionalStringArrayField(value, "sshOptions"),
     ...optionalStringArrayField(value, "remoteCommandArgs"),
@@ -183,17 +204,6 @@ function parseSshInput(value: unknown): CmuxOpenSshInput {
   };
 }
 
-function parseSshAuth(value: unknown): Exclude<Extract<CmuxOpenSshInput, object>["auth"], undefined> {
-  if (!isRecord(value)) throw new Error(`cmux.open ssh.auth must be an object`);
-  if (value.type === "token") {
-    return { type: "token", token: requiredString(value, "token") };
-  }
-  if (value.type === "privateKey") {
-    return { type: "privateKey", privateKey: requiredString(value, "privateKey") };
-  }
-  throw new Error(`cmux.open ssh.auth.type must be "token" or "privateKey"`);
-}
-
 function parseRemoteReadyOptions(value: unknown): boolean | CmuxRemoteReadyOptions {
   if (typeof value === "boolean") return value;
   if (!isRecord(value)) throw new Error(`cmux.open waitForRemoteReady must be a boolean or object`);
@@ -208,27 +218,22 @@ function cmuxSshOptionsForInput(ssh: CmuxOpenSshInput): CmuxSshOptions {
   if (typeof ssh === "string") return { destination: ssh };
 
   const destination = ssh.destination ?? sshDestination(ssh);
-  const sshOptions = [
-    ...(ssh.auth?.type === "token" ? freestyleTokenSshOptions : []),
-    ...(ssh.sshOptions ?? []),
-  ];
   return {
     destination,
-    port: ssh.port,
-    identity: ssh.identity,
-    sshOptions,
-    remoteCommandArgs: ssh.remoteCommandArgs,
-    initialCommand: ssh.initialCommand,
-    terminalStartupCommand: ssh.terminalStartupCommand ?? ssh.command,
-    autoConnect: ssh.autoConnect,
-    skipDaemonBootstrap: ssh.skipDaemonBootstrap,
+    ...(ssh.port !== undefined ? { port: ssh.port } : {}),
+    ...(ssh.identity !== undefined ? { identity: ssh.identity } : {}),
+    ...(ssh.sshOptions?.length ? { sshOptions: ssh.sshOptions } : {}),
+    ...(ssh.remoteCommandArgs !== undefined ? { remoteCommandArgs: ssh.remoteCommandArgs } : {}),
+    ...(ssh.initialCommand !== undefined ? { initialCommand: ssh.initialCommand } : {}),
+    ...(ssh.terminalStartupCommand !== undefined ? { terminalStartupCommand: ssh.terminalStartupCommand } : {}),
+    ...(ssh.autoConnect !== undefined ? { autoConnect: ssh.autoConnect } : {}),
+    ...(ssh.skipDaemonBootstrap !== undefined ? { skipDaemonBootstrap: ssh.skipDaemonBootstrap } : {}),
   };
 }
 
 function sshDestination(ssh: Extract<CmuxOpenSshInput, object>): string {
   if (!ssh.host) throw new Error(`cmux.open ssh.host is required when ssh.destination is omitted`);
   if (!ssh.username) throw new Error(`cmux.open ssh.username is required when ssh.destination is omitted`);
-  if (ssh.auth?.type === "token") return `${ssh.username},${ssh.auth.token}@${ssh.host}`;
   return `${ssh.username}@${ssh.host}`;
 }
 

package/src/index.test.ts

@@ -6,7 +6,6 @@ import { describe, expect, test } from "bun:test";
 import type { ProviderStorage, ProviderStorageRecord } from "@rigkit/engine";
 import type { JsonValue } from "@rigkit/sdk";
 import {
-  CMUX_OPEN_CAPABILITY,
   CmuxCommandError,
   cmux,
   cmuxProviderPlugin,
@@ -403,21 +402,20 @@ 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({
       name: "website",
       ssh: {
         kind: "ssh",
-        host: "vm-ssh.freestyle.sh",
-        username: "vm_123",
-        auth: { type: "token", token: "token_123" },
-        command: "ssh vm_123:token_123@vm-ssh.freestyle.sh",
+        destination: "vm_123,token_123@vm-ssh.freestyle.sh",
+        sshOptions: ["ServerAliveInterval=15"],
       },
       cwd: "/workspace/site",
       command: "pnpm dev",
       url: "http://localhost:4321",
-    }, { client });
+    }, { client, logger: (message) => logs.push(message) });
 
     expect(result).toEqual({
       sessionId: "workspace-1",
@@ -434,15 +432,7 @@ describe("cmux sdk", () => {
         params: expect.objectContaining({
           destination: "vm_123,token_123@vm-ssh.freestyle.sh",
           name: "website",
-          terminalStartupCommand: "ssh vm_123:token_123@vm-ssh.freestyle.sh",
-          sshOptions: [
-            "StrictHostKeyChecking=no",
-            "UserKnownHostsFile=/dev/null",
-            "LogLevel=ERROR",
-            "IdentitiesOnly=yes",
-            "IdentityFile=/dev/null",
-            "ControlMaster=no",
-          ],
+          sshOptions: ["ServerAliveInterval=15"],
         }),
       },
       {
@@ -490,19 +480,54 @@ describe("cmux sdk", () => {
         params: "workspace-1",
       },
     ]);
+    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 () => {
+    const calls: Array<{ method: string; params: unknown }> = [];
+    const client = fakeOpenClient(calls);
+
+    await openCmux({
+      name: "website",
+      ssh: {
+        kind: "ssh",
+        destination: "vm_123,token_123@vm-ssh.freestyle.sh",
+        terminalStartupCommand: "ssh -tt vm_123:token_123@vm-ssh.freestyle.sh",
+      },
+    }, { client });
+
+    expect(calls[0]).toEqual({
+      method: "ssh",
+      params: expect.objectContaining({
+        destination: "vm_123,token_123@vm-ssh.freestyle.sh",
+        name: "website",
+        terminalStartupCommand: "ssh -tt vm_123:token_123@vm-ssh.freestyle.sh",
+      }),
+    });
   });
 
   test("exposes a provider facade that requests cmux.open from the local host", async () => {
     const definition = cmux.provider();
     expect(definition.providerId).toBe("cmux");
     expect(definition.plugin).toBe(cmuxProviderPlugin);
-    expect(cmux.capabilities.open).toBe(CMUX_OPEN_CAPABILITY);
 
     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",
@@ -513,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;
         },
       },
@@ -526,6 +551,7 @@ describe("cmux sdk", () => {
       {
         capability: "cmux.open",
         params: { name: "workspace" },
+        options: { nodePath: "operation.open" },
       },
     ]);
     expect(session.sessionId).toBe("workspace-1");
@@ -542,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({
@@ -554,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/index.ts

@@ -487,6 +487,8 @@ export {
   cmux,
   cmuxProviderPlugin,
   provider as defineCmuxProvider,
+  parseCmuxOpenResult,
+  requestCmuxOpen,
   type CmuxProviderDefinition,
   type CmuxRuntime,
 } from "./provider.ts";

package/src/provider.ts

@@ -5,7 +5,6 @@ import {
 } from "@rigkit/sdk";
 import type { BaseProviderPlugin, WorkflowProviderController } from "@rigkit/engine";
 import {
-  CMUX_OPEN_CAPABILITY,
   CMUX_OPEN_CAPABILITY_ID,
   type CmuxOpenInput,
   type CmuxOpenResult,
@@ -30,10 +29,6 @@ export function provider(): CmuxProviderDefinition {
 
 export const cmux = {
   provider,
-  capability: CMUX_OPEN_CAPABILITY,
-  capabilities: {
-    open: CMUX_OPEN_CAPABILITY,
-  },
 };
 
 export const cmuxProviderPlugin: BaseProviderPlugin = {
@@ -42,37 +37,43 @@ 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, { 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, options);
+    return {
+      ...parseCmuxOpenResult(session.result),
+      closed: session.closed,
+    };
+  }
+  if (!local.requestCapability) {
+    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, options),
+  );
   return {
-    async open(input) {
-      if (local.requestCapabilitySession) {
-        const session = await local.requestCapabilitySession<CmuxOpenResult>(CMUX_OPEN_CAPABILITY_ID, input);
-        return {
-          ...parseCmuxOpenResult(session.result),
-          closed: session.closed,
-        };
-      }
-      if (!local.requestCapability) {
-        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),
-      );
-      return {
-        ...result,
-        closed: new Promise<void>(() => {}),
-      };
-    },
+    ...result,
+    closed: new Promise<void>(() => {}),
   };
 }
 
-function parseCmuxOpenResult(value: unknown): CmuxOpenResult {
+export function parseCmuxOpenResult(value: unknown): CmuxOpenResult {
   if (!isRecord(value)) throw new Error(`cmux.open returned a non-object result`);
   const sessionId = stringField(value, "sessionId");
   if (!sessionId) throw new Error(`cmux.open result is missing sessionId`);

package/src/version.ts

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