fix: logs in hooks

Author: cfoust

pkg/cy/client.go

@@ -136,7 +136,12 @@ func (c *Cy) runHook(client *Client, funcName string) {
 	ctx, cancel := context.WithTimeout(client.Ctx(), 5*time.Second)
 	defer cancel()
 
-	err := c.ExecuteFunction(ctx, client, funcName)
+	err := c.ExecuteFunction(
+		ctx,
+		client,
+		janet.Params{Dyns: c.logPipe.Dyns()},
+		funcName,
+	)
 	if err == nil || errors.Is(err, context.Canceled) ||
 		errors.Is(err, context.DeadlineExceeded) {
 		return
@@ -403,6 +408,7 @@ func (c *Client) findNewPane() error {
 	return c.cy.ExecuteFunction(
 		c.Ctx(),
 		c,
+		janet.Params{Dyns: c.cy.logPipe.Dyns()},
 		"shell/attach",
 		cwd,
 	)

pkg/cy/module.go

@@ -370,6 +370,9 @@ func (c *Cy) pollNodeEvents(ctx context.Context, events <-chan events.Msg) {
 				err := c.ExecuteFunction(
 					ctx,
 					client,
+					janet.Params{
+						Dyns: c.logPipe.Dyns(),
+					},
 					"register/set",
 					event.Register,
 					event.Text,

pkg/janet/exec.go

@@ -327,16 +327,22 @@ func (v *VM) WrapFile(
 func (v *VM) ExecuteFunction(
 	ctx context.Context,
 	user interface{},
+	params Params,
 	funcName string,
-	params ...interface{},
+	args ...interface{},
 ) error {
 	out, err := v.ExecuteCall(
 		ctx,
 		nil,
-		CallString(fmt.Sprintf(
-			`(yield %s)`,
-			funcName,
-		)),
+		Call{
+			Code: []byte(fmt.Sprintf(
+				`(yield %s)`,
+				funcName,
+			)),
+			Options: CallOptions{
+				Dyns: params.Dyns,
+			},
+		},
 	)
 	if err != nil {
 		return err
@@ -348,7 +354,7 @@ func (v *VM) ExecuteFunction(
 		return err
 	}
 
-	return fun.Call(ctx, user, Params{}, params...)
+	return fun.Call(ctx, user, params, args...)
 }
 
 func (v *VM) Execute(ctx context.Context, code string) error {

pkg/janet/exec_test.go

@@ -16,36 +16,39 @@ func TestExecuteFunction(t *testing.T) {
 		err := vm.Execute(ctx, `(defn test-add [a b] (+ a b))`)
 		require.NoError(t, err)
 
-		err = vm.ExecuteFunction(ctx, nil, "test-add", 2, 3)
+		err = vm.ExecuteFunction(ctx, nil, Params{}, "test-add", 2, 3)
 		require.NoError(t, err)
 	})
 
 	t.Run("non-existent function", func(t *testing.T) {
-		err := vm.ExecuteFunction(ctx, nil, "non-existent-function")
+		err := vm.ExecuteFunction(ctx, nil, Params{}, "non-existent-function")
 		require.Error(t, err)
 	})
 
 	t.Run("function with different parameter types", func(t *testing.T) {
 		err := vm.Execute(ctx, `(defn test-params [num str bool]
 			(print "num:" num "str:" str "bool:" bool))`)
 		require.NoError(t, err)
-		err = vm.ExecuteFunction(ctx, nil, "test-params", 42, "hello", true)
+		err = vm.ExecuteFunction(
+			ctx, nil, Params{},
+			"test-params", 42, "hello", true,
+		)
 		require.NoError(t, err)
 	})
 
 	t.Run("function with no parameters", func(t *testing.T) {
 		err := vm.Execute(ctx, `(defn test-no-params [] (print "no params"))`)
 		require.NoError(t, err)
 
-		err = vm.ExecuteFunction(ctx, nil, "test-no-params")
+		err = vm.ExecuteFunction(ctx, nil, Params{}, "test-no-params")
 		require.NoError(t, err)
 	})
 
 	t.Run("function that errors", func(t *testing.T) {
 		err := vm.Execute(ctx, `(defn test-error [] (error "test error"))`)
 		require.NoError(t, err)
 
-		err = vm.ExecuteFunction(ctx, nil, "test-error")
+		err = vm.ExecuteFunction(ctx, nil, Params{}, "test-error")
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "test error")
 	})
@@ -63,7 +66,7 @@ func TestExecuteFunction(t *testing.T) {
 		err = vm.Execute(ctx, `(defn test-with-user [] (test-user-context))`)
 		require.NoError(t, err)
 		testUser := "test-user"
-		err = vm.ExecuteFunction(ctx, testUser, "test-with-user")
+		err = vm.ExecuteFunction(ctx, testUser, Params{}, "test-with-user")
 		require.NoError(t, err)
 		require.Equal(t, testUser, receivedUser)
 	})
@@ -75,7 +78,7 @@ func TestExecuteFunction(t *testing.T) {
 		)
 		require.NoError(t, err)
 
-		err = vm.ExecuteFunction(ctx, nil, "test-var-fn")
+		err = vm.ExecuteFunction(ctx, nil, Params{}, "test-var-fn")
 		require.NoError(t, err)
 	})
 
@@ -86,19 +89,22 @@ func TestExecuteFunction(t *testing.T) {
 		)
 		require.NoError(t, err)
 
-		err = vm.ExecuteFunction(ctx, nil, "test-complex-return")
+		err = vm.ExecuteFunction(ctx, nil, Params{}, "test-complex-return")
 		require.NoError(t, err)
 	})
 
 	t.Run("built-in function", func(t *testing.T) {
-		err = vm.ExecuteFunction(ctx, nil, "length", []int{1, 2, 3, 4})
+		err = vm.ExecuteFunction(
+			ctx, nil, Params{},
+			"length", []int{1, 2, 3, 4},
+		)
 		require.NoError(t, err)
 	})
 
 	t.Run("wrong parameter count", func(t *testing.T) {
 		err := vm.Execute(ctx, `(defn test-param-count [a b] (+ a b))`)
 		require.NoError(t, err)
-		err = vm.ExecuteFunction(ctx, nil, "test-param-count", 1)
+		err = vm.ExecuteFunction(ctx, nil, Params{}, "test-param-count", 1)
 		require.Error(t, err)
 	})
 
@@ -109,7 +115,7 @@ func TestExecuteFunction(t *testing.T) {
 		cancelledCtx, cancel := context.WithCancel(ctx)
 		cancel()
 
-		err = vm.ExecuteFunction(cancelledCtx, nil, "test-slow")
+		err = vm.ExecuteFunction(cancelledCtx, nil, Params{}, "test-slow")
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "context canceled")
 	})