@rigkit/provider-cmux 0.2.1 → 0.2.3

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.1",
+  "version": "0.2.3",
   "type": "module",
   "repository": {
     "type": "git",
@@ -17,8 +17,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@rigkit/sdk": "0.2.1",
-    "@rigkit/engine": "0.2.1"
+    "@rigkit/sdk": "0.2.3",
+    "@rigkit/engine": "0.2.3"
   },
   "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

@@ -41,15 +41,6 @@ export type CmuxOpenHostOptions = {
   clientOptions?: CmuxClientOptions;
 };
 
-const freestyleTokenSshOptions = [
-  "StrictHostKeyChecking=no",
-  "UserKnownHostsFile=/dev/null",
-  "LogLevel=ERROR",
-  "IdentitiesOnly=yes",
-  "IdentityFile=/dev/null",
-  "ControlMaster=no",
-] as const;
-
 export function createCmuxOpenHostCapability(
   options: CmuxOpenHostOptions = {},
 ): CmuxHostCapabilityHandler {
@@ -171,8 +162,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 +172,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 +186,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,
@@ -409,10 +408,8 @@ describe("cmux sdk", () => {
       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",
@@ -434,15 +431,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,13 +479,36 @@ describe("cmux sdk", () => {
         params: "workspace-1",
       },
     ]);
+    expect(calls[0]?.params).not.toHaveProperty("terminalStartupCommand");
+  });
+
+  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: {} },

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 = {
@@ -50,29 +45,34 @@ export const cmuxProviderPlugin: BaseProviderPlugin = {
 
 function createCmuxRuntime(local: LocalWorkspaceRuntime): CmuxRuntime {
   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>(() => {}),
-      };
-    },
+    open: async (input) => await requestCmuxOpen(local, input),
+  };
+}
+
+export async function requestCmuxOpen(
+  local: LocalWorkspaceRuntime,
+  input: CmuxOpenInput,
+): Promise<CmuxOpenSession> {
+  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>(() => {}),
   };
 }
 
-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.1";
+export const RIGKIT_PROVIDER_CMUX_VERSION = "0.2.3";